Hibernate中的单向一对多关联

       Hibernate中的单向一对多关联，这里举例 班级对学生 的单向一对多关联，即一个班级可以有多个学生。

       那么在Hibernate中实体对象间如何体现出单向一对多的关联关系呢？如 班级对学生 这个例子而言，单向一对多关联，可以在“一方”添加 一个集合，如 Set集合，其中集合中保存“多”方的信息，如 班级类 中添加 一个集合，这里采用Set集合（保存的学生对象将不重复），Set集合中保存多个 学生对象。（意味着 一个班级有多个学生）。当然添加该属性后还要 在对象关系映射配置文件中添加相应的配置。具体查看下文的程序。

       hibernate-one2many 项目结构如下：

       首先创建一个工具类 HibernateUtil.java

package com.imooc.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

/**
 * Created by DreamBoy on 2016/5/18.
 */
public class HibernateUtil {
    private static SessionFactory sessionFactory;
    private static Session session;

    static {
        //创建Configuration对象，读取hibernate.cfg.xml文件，完成初始化
        Configuration config = new Configuration().configure();
        /*StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder()
                .applySettings(config.getProperties());
        StandardServiceRegistry ssr = ssrb.build();
        sessionFactory = config.buildSessionFactory(ssr);
        */

        //创建服务注册对象
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry();
        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory(serviceRegistry);

    }

    //获取SessionFactory
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    //获得Session
    public static Session getSession() {
        session = sessionFactory.openSession();
        return session;
    }

    //关闭Session
    public static void closeSession(Session session) {
        if(session != null) {
            session.close();
        }
    }
}

       创建 SQL 语句在数据库 hibernate2 中建表结构和关系（student.sql）：

CREATE TABLE grade (
  gid INT PRIMARY KEY,
  gname VARCHAR(20) NOT NULL,
  gdesc VARCHAR(50)
);

CREATE TABLE student (
  sid INT PRIMARY KEY,
  sname VARCHAR(20) NOT NULL,
  sex CHAR(2),
  gid INT
);

ALTER TABLE student ADD CONSTRAINT fk_student_gid FOREIGN KEY (gid) REFERENCES grade(gid);

       先在MySQL中创建好名为hibernate2的数据库，执行上述的SQL语句。

       在 com.imooc.entity 包中创建两个实体：

       Student.java

package com.imooc.entity;

import java.io.Serializable;

/**
 * Created by DreamBoy on 2016/5/18.
 */
public class Student implements Serializable {
    private int sid;
    private String sname;
    private String sex;

    public Student() {
    }

    public Student(String sname, String sex) {
        this.sname = sname;
        this.sex = sex;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

       Student.hbm.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="com.imooc.entity.Student" table="student">
        <id name="sid" column="sid" type="java.lang.Integer">
            <generator class="increment"/>
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" not-null="true"/>
        </property>
        <property name="sex">
            <column name="sex"/>
        </property>
    </class>
</hibernate-mapping>

        Grade.java

package com.imooc.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by DreamBoy on 2016/5/18.
 */
public class Grade implements Serializable {
    private int gid;
    private String gname;
    private String gdesc;
    //在一方定义一个多方的集合
    private Set<Student> students = new HashSet<>();

    public Grade() {
    }

    public Grade(int gid, String gname, String gdesc, Set<Student> students) {
        this.gid = gid;
        this.gname = gname;
        this.gdesc = gdesc;
        this.students = students;
    }

    public Grade(String gname, String gdesc) {
        this.gname = gname;
        this.gdesc = gdesc;
    }

    public int getGid() {
        return gid;
    }

    public void setGid(int gid) {
        this.gid = gid;
    }

    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public String getGdesc() {
        return gdesc;
    }

    public void setGdesc(String gdesc) {
        this.gdesc = gdesc;
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

        Grade.hbm.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="com.imooc.entity.Grade" table="grade">
        <id name="gid" column="gid" type="java.lang.Integer">
            <generator class="increment"/>
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"/>
        </property>
        <property name="gdesc">
            <column name="gdesc"/>
        </property>
        <!-- 配置单向的一对多关联关系 -->
        <set name="students" table="student">
            <!-- 指定关联的外键列 -->
            <key column="gid"></key>
            <one-to-many class="com.imooc.entity.Student"/>
        </set>
    </class>
</hibernate-mapping>

       项目中Hibernate的配置文件 hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <!-- 下面的 hibernate 指的是 数据库名，即所用的数据库 -->
        <property name="connection.url">jdbc:mysql:///hibernate2?useUnicode=true&characterEncoding=UTF-8</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <!--<property name="hbm2ddl.auto">create</property>-->
        <property name="hbm2ddl.auto">update</property>

        <!-- 指定映射文件的路径 -->
        <mapping resource="com/imooc/entity/Grade.hbm.xml"/>
        <mapping resource="com/imooc/entity/Student.hbm.xml"/>

        <!-- DB schema will be updated if needed -->
        <!-- <property name="hbm2ddl.auto">update</property> -->
    </session-factory>
</hibernate-configuration>

       在 com.imooc.test 包中添加测试类  test.java（测试 增删查改操作）

package com.imooc.test;

/**
 * Created by DreamBoy on 2016/5/18.
 */

import com.imooc.entity.Grade;
import com.imooc.entity.Student;
import com.imooc.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

import java.util.Set;

/**
 * 单向 一对多关系（班级--》学生）
 * 建立关联关系后，可以方便地从一个对象导航到另一个对象
 * 注意关联的方向：这里只是 1到多；只能查询到一个班级所具有的学生，但不能查询一个学生属于哪个班级
 */
public class Test {
    public static void main(String[] args) {
        //add();
        //findStudentsByGrade();
        //update();
        delete();
    }

    //将学生添加到班级
    public static void add() {
        Grade g = new Grade("Java一班", "Java软件开发一班");
        Student stu1 = new Student("张三", "男");
        Student stu2 = new Student("木女神", "女");

        //如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
        g.getStudents().add(stu1);
        g.getStudents().add(stu2);

        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        session.save(g);
        session.save(stu1);
        session.save(stu2);
        tx.commit();
        HibernateUtil.closeSession(session);
    }

    //查询班级中包含的学生信息
    public static void findStudentsByGrade() {
        Session session = HibernateUtil.getSession();
        Grade grade = (Grade) session.get(Grade.class, 1);
        System.out.println(grade.getGname() + ", " + grade.getGdesc());

        Set<Student> students = grade.getStudents();
        for(Student stu : students) {
            System.out.println(stu.getSname() + ", " + stu.getSex());
        }
    }

    //修改学生信息
    public static void update() {
        Grade g = new Grade("Java二班", "Java软件开发二班");
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Student stu = (Student) session.get(Student.class, 1);
        g.getStudents().add(stu);
        session.save(g);
        tx.commit();
        HibernateUtil.closeSession(session);
    }

    //删除学生信息
    public static void delete() {
        Session session = HibernateUtil.getSession();
        Transaction tx = session.beginTransaction();
        Student stu = (Student) session.get(Student.class, 2);
        session.delete(stu);
        tx.commit();
        HibernateUtil.closeSession(session);
    }
}<span style="font-size:18px;">
</span>

总结：