Hibernate单向一对多关联

如何在数据库中表示一个班级有多个学生？或者说一个学生属于某个班级？
在数据库中，可以通过添加主外键的关联，表现一对多的关系。

如何在Java或者Hibernate中表示如上的关系？
通过在一方持有多方的集合实现，即在”一”的一端中使用<set>元素表示持有”多”的一端的对象。

单向一对多关联

单向的一对多关联映射关系主要是通过外键来关联的。一对多的关联映射是在表示“多”的一方的数据中增加一个外键，并由“一”的一方指向“多”的一方。

单向一对多关联的持久化类里需要包含一个集合属性，在“一”的一方访问“多”的一方时，“多”的一方将以集合的形式来体现。

建立一对多映射时，需要在“一”端的映射文件中使用 one-to-many 元素来映射关联实体。one-to-many 元素可以包含的可选属性如下：

• class: 指定管理类的名称
• not-found: 该属性取值为exception 或 ignore。当取值为exception时，表明若从表记录所参照的主表记录不存在时，Hibernate会抛出异常；当取值为ignore时，则表示忽略该异常。

在数据库创建grade班级表，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);

首选创建HibernateUtil类，位于com.imooc.util包下：

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;

//工具类 用来定义会话的获取和关闭
public class HibernateUtil {
    private static SessionFactory sessionFactory;
    private static Session session;

    static {
        // 创建Configuration对象，读取hibernate.cfg.xml文件，完成初始化
        Configuration config = new Configuration().configure();
        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();
        }
    }

}

在com.imooc.entity包下，创建Grade和Student持久化类。
Grade类如下：

package com.imooc.entity;

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

public class Grade implements Serializable {
    private int gid;
    private String gname;
    private String gdesc;
    //在一方定义一个多方的集合
    private Set<Student> students = new HashSet<Student>();

    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;
    }

    //构造方法
    public Grade() {
        super();
    }

    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;
    }




}

Student类如下：

package com.imooc.entity;

import java.io.Serializable;

public class Student implements Serializable {
    private int sid;
    private String sname;
    private String 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;
    }

    public Student() {

    }

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




}

创建Grade和Student类的映射文件Grade.hbm.xml与Student.hbm.xml文件。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-12 21:51:49 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.imooc.entity.Grade" table="grade">
        <id name="gid" type="int">
            <column name="gid" />
            <generator class="increment" />
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname"  length="20" not-null="true"/>
        </property>
        <property name="gdesc" type="java.lang.String">
            <column name="gdesc" />
        </property>
        <!--  配置单向的一对多关联关系 -->
        <set name="students" table="student">
                <!-- 指定关联的外键列 -->
            <key>
                <column name="gid" />
            </key>
            <one-to-many class="com.imooc.entity.Student" />
        </set>
    </class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-12 21:51:49 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.imooc.entity.Student" table="student">
        <id name="sid" type="int">
            <column name="sid" />
            <generator class="increment" />
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" />
        </property>
        <property name="sex" type="java.lang.String">
            <column name="sex" />
        </property>
    </class>
</hibernate-mapping>

并且要在hibernate.cfg.xml文件中配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//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>
            <property name="connection.url">jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&amp;characterEncoding=UTF-8</property>
            <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

            <property name="show_sql">true</property>
            <property name="format_sql">false</property>
            <property name="hbm2ddl.auto">update</property>

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

    </session-factory>
</hibernate-configuration>

---

创建测试类Test
添加学生到班级

    //将学生添加到班级
    public static void add()
    {
        Grade g = new Grade("一年级一班", "xx小学一年级一班");
        Student s1 = new Student("张三", "男");
        Student s2 = new Student("小美", "女");

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

        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        session.save(g);
        session.save(s1);
        session.save(s2);
        transaction.commit();

        HibernateUtil.closeSession(session);
    }

可以发现，在执行时，hibernate执行了如下语句：

Hibernate: select max(gid) from grade
Hibernate: select max(sid) from student
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
Hibernate: update student set gid=? where sid=?
Hibernate: update student set gid=? where sid=?

查询学生信息

    //查询班级中包含的学生
    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());
        }
    }

结果为：

Hibernate: select grade0_.gid as gid1_0_0_, grade0_.gname as gname2_0_0_, grade0_.gdesc as gdesc3_0_0_ from grade grade0_ where grade0_.gid=?
一年级一班,xx小学一年级一班
Hibernate: select students0_.gid as gid4_0_1_, students0_.sid as sid1_1_1_, students0_.sid as sid1_1_0_, students0_.sname as sname2_1_0_, students0_.sex as sex3_1_0_ from student students0_ where students0_.gid=?
小美,女
张三,男

修改学生信息

    //修改学生信息
    public static void  update() {
        Grade g = new Grade("一年级二班", "xx小学一年级一班");

        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        Student stu =  (Student) session.get(Student.class, 1);
        g.getStudents().add(stu);
        session.save(g);
        transaction.commit();
        HibernateUtil.closeSession(session);

    }

结果为：

Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.sex as sex3_1_0_ from student student0_ where student0_.sid=?
Hibernate: select max(gid) from grade
Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
Hibernate: update student set gid=? where sid=?

删除学生信息

    //删除学生信息
    public static void delete()
    {
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        Student stu =  (Student) session.get(Student.class, 2);
        session.delete(stu);
        transaction.commit();
        HibernateUtil.closeSession(session);
    }

输出结果为：

Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.sex as sex3_1_0_ from student student0_ where student0_.sid=?
Hibernate: delete from student where sid=?

总结

单向一对多映射，在一方定义一个多方的集合，然后在映射文件中通过set元素进行一对多映射的配置。在set元素中常用的属性

属性	含义和作用	必须	默认值
name	映射类属性的名称	Y
table	关联类的目标数据库表	N
lazy	指定关联对象是否使用延迟加载	N	proxy
inverse	标识双向关联中被动的一方	N	false