14. Hibernate 一对多双向关联映射

1. 前言

本节课程和大家一起聊聊一对多关联映射。通过本节课程，你将了解到：

如何实现一对多关联映射；
如何实现双向一对多关联映射；
关联映射中的级联操作。

2. 一对多关联映射

关系型数据库中表与表中的数据存在一对多（或多对一）关系。

如学生表、班级表。一个班级有多个学生，多个学生可以在同一个班级。

一对多或多对一本质上是一样的，如同一块硬币的正面和反面，只是看待事物的角度不同而已。

数据库中有学生表、班级表。使用 Hibernate 进行数据操作时，程序中就应该有学生类、班级类。

同时学生类、班级类应该使用 OOP 语法描述出如同学生表和班级表一样的关系。并且还要让 Hibernate 看得懂。

有了前面的基础，直接上代码：

创建班级类：

@Entity
public class ClassRoom {private Integer classRoomId;private String classRoomName;private String classRoomDesc;@Id@GeneratedValue(strategy = GenerationType.IDENTITY)public Integer getClassRoomId() {return classRoomId;}

需求：查询学生时，得到学生所在班级信息。

进入学生类，添加如下代码，描述学生类和班级类的关系：

private ClassRoom classRoom;

除此之外，还需要让 Hibernate 知道，这个对象属性的值来自于班级表中的对应数据，进一步修改代码：

private ClassRoom classRoom;
@ManyToOne(targetEntity=ClassRoom.class)
@JoinColumn(name="classRoomId")
public ClassRoom getClassRoom() {return classRoom;
}

@ManyToOne 告诉 Hibernate，从学生的角度来看，学生是多的一边，查询班级表可以得到学生所在班级信息。
@JoinColumn 告诉 Hibernate 需要带着指定的字段值到班级表中匹配数据。

修改 Hibernate 主配置文件中内容：

<property name="hbm2ddl.auto">create</property>
<mapping class="com.mk.po.Student" />
<mapping class="com.mk.po.ClassRoom" />

为了让事情变得简单明了，在主配置文件中只保留学生类和班级类的映射关系。

学生类中的所有属性描述：

private Integer stuId;private String stuName;private String stuSex;private String stuPassword;private Blob stuPic;private ClassRoom classRoom;@ManyToOne(targetEntity=ClassRoom.class)@JoinColumn(name="classRoomId")public ClassRoom getClassRoom() {return classRoom;}

使用上一节课的模板对象跑一个空测试实例：

@Test
public void testGetByTemplate() {HibernateTemplate<Student> hibernateTemplate=new HibernateTemplate<Student>();	
}

目的是让 Hibernate 重新创建学生表、班级表。别忘记啦，自动创建表后，修改回：

<property name="hbm2ddl.auto">update</property>

进入 MySql，在学生表、班级表中手工添加几条测试数据：

到了完成需求的时候，测试下面实例：

HibernateTemplate<Student> hibernateTemplate = new HibernateTemplate<Student>();hibernateTemplate.template(new Notify<Student>() {@Overridepublic Student action(Session session) {Student stu=(Student)session.get(Student.class, new Integer(1));System.out.println("学生姓名："+stu.getStuName());System.out.println("学生所在班级："+stu.getClassRoom().getClassRoomName());return stu_;}});

控制台输出结果：

Hibernate: selectstudent0_.stuId as stuId1_1_1_,student0_.classRoomId as classRoo6_1_1_,student0_.stuName as stuName2_1_1_,student0_.stuPassword as stuPassw3_1_1_,student0_.stuPic as stuPic4_1_1_,student0_.stuSex as stuSex5_1_1_,classroom1_.classRoomId as classRoo1_0_0_,classroom1_.classRoomDesc as classRoo2_0_0_,classroom1_.classRoomName as classRoo3_0_0_ fromStudent student0_ left outer joinClassRoom classroom1_ on student0_.classRoomId=classroom1_.classRoomId wherestudent0_.stuId=?
学生姓名：Hibernate
学生所在班级：c1911

Hibernate 使用 left outer join 构建了一条多表查询语句！

3. 双向一对多关联映射

需求：查询班级时，想知道班上有多少名学生，又应该如何映射？

进入班级类，添加如下属性：

private Set<Student> students;

使用集合属性 students，描述了一个班有多名学生。

为什么使用 Set 集合？

因为一个班级内不可能出现两个完全相同的学生对象。

这还仅仅只是 OOP 层面上的关系，还需要告诉 Hibernate 应该如何填充数据。

添加下面代码：

private Set<Student> students;
@OneToMany(targetEntity=Student.class,mappedBy="classRoom")
public Set<Student> getStudents() {return students;
}

@OneToMany：很直白的说明了一个班级会有多名学生，指引 Hibernate 在填充数据时，要找到所有学生，别遗漏了；
属性 mappedBy=“classRoom”： 告诉 Hibernate，班级和学生之间的关系在学生类中已经说的够明白了，应该不需要再废话了吧。

OK！把前面的测试实例改为查询班级信息：

HibernateTemplate<ClassRoom> hibernateTemplate = new HibernateTemplate<ClassRoom>();hibernateTemplate.template(new Notify<ClassRoom>() {@Overridepublic ClassRoom action(Session session) {ClassRoom classRoom=(ClassRoom)session.get(ClassRoom.class, new Integer(1));System.out.println("班级名称："+classRoom.getClassRoomName());
System.out.println("------我是分隔线------------------------");System.out.println("班级学生人数："+classRoom.getStudents().size());return classRoom;}});

查看控制台输出结果：

Hibernate: selectclassroom0_.classRoomId as classRoo1_0_0_,classroom0_.classRoomDesc as classRoo2_0_0_,classroom0_.classRoomName as classRoo3_0_0_ fromClassRoom classroom0_ whereclassroom0_.classRoomId=?
班级名称：c1911
------我是分隔线------------------------
Hibernate: selectstudents0_.classRoomId as classRoo6_0_1_,students0_.stuId as stuId1_1_1_,students0_.stuId as stuId1_1_0_,students0_.classRoomId as classRoo6_1_0_,students0_.stuName as stuName2_1_0_,students0_.stuPassword as stuPassw3_1_0_,students0_.stuPic as stuPic4_1_0_,students0_.stuSex as stuSex5_1_0_ fromStudent students0_ wherestudents0_.classRoomId=?
班级学生人数：2

会发现一个很有意思的地方。Hibernate 查询班级时，构建了两条 SQL。

先查询班级，当需要学生信息时，才构建查询学生的 SQL。

大家应该也猜出来了，当从学生表查询班级表时，Hibernate 采用的是立即策略。

当查询从班级表查询到学生表时，Hibernate 采用的是延迟加载策略。

采用延迟加载都只有一个目的，需要时加载，提高响应速度。

现在，学生类和班级类的映射配置信息，能让 Hibernate 自动从学生表查询到班级表，也能从班级表查询到学生表。

这种 2 个实体类中的映射关系就称为双向一对多关联映射。

无论是 @ManyToOne 还是 @OneToMany 注解都有 fetch 属性，可以设置的值有 2 个选择：

FetchType.EAGER
FetchType.LAZY。

所以，在双向一对多关联映射可以选择是否启用延迟加载，这和一对一关联映射中是一样的，就不在此重复复述。

是否采用延迟加载，由项目逻辑决定。

4. 一对多关联映射中的级联操作

什么是级联操作？

关系型数据库中由主外键维系的两张表，具有主从关系。

如学生表和班级表，班级班是主表，学生表是从表。

类似于删除某一个班级的信息，则需要先删除所在班的学生信息，再删除班级信息，这个操作就是级联操作。

所谓级联操作，指操作一张表时，是否会牵连到与之有关联的其它表。

现在，咱们是使用 Hibernate 进行数据操作，不可能还要劳驾自己亲力亲为吧。只需要做些简单配置，就可以让 Hibernate 自动做级联操作。

进入班级类，修改代码如下：

@OneToMany(targetEntity=Student.class,mappedBy="classRoom",cascade=CascadeType.REMOVE)public Set<Student> getStudents() {return students;}

很简单，只需要使用 @OneToMany 的 cascade 属性，就能让 Hibernate 明白如何做级联操作。默认情况下，没有级联效应。

cascade 是一个枚举类型：

public enum CascadeType {ALL,PERSIST,MERGE,REMOVE,REFRESH,DETACH
}

ALL： 级联所有操作；
PERSIST： 级联新增；
MERGE： 级联更新或者新增；
REMOVE： 级联删除；
REFRESH： 级联刷新；
DETACH： 级联分离。

测试删除班级实例：

HibernateTemplate<ClassRoom> hibernateTemplate = new HibernateTemplate<ClassRoom>();hibernateTemplate.template(new Notify<ClassRoom>() {@Overridepublic ClassRoom action(Session session) {ClassRoom classRoom=(ClassRoom)session.get(ClassRoom.class, new Integer(1));	session.delete(classRoom);return null;}});

如果不添加 cascade 相关说明，因为有学生引用班级信息，班级信息是不能被删除的。

添加后再测试，查看表中内容：班级以及班级所在学生信息全部删除！

删除班级时能级联删除学生，反过来，删除学生能删除班级吗？

想法很好，实践是检验真理的唯一手段，学生类中修改成如下代码：

@ManyToOne(targetEntity=ClassRoom.class,cascade=CascadeType.REMOVE)@JoinColumn(name="classRoomId")public ClassRoom getClassRoom() {return classRoom;}

测试实例：

HibernateTemplate<Student> hibernateTemplate = new HibernateTemplate<Student>();hibernateTemplate.template(new Notify<Student>() {@Overridepublic Student action(Session session) {Student stu=(Student)session.get(Student.class, new Integer(2));session.delete(stu);return stu;}});

结果很残酷！学生被删除了，班级也被删除了！

级联级联，只要设置了级联，不管删除学生还是班级，只要在对应表中有引用关系的数据就会被删除。

现在，学生类、班级类中的级联删除都打开了。如果对下面情形的数据（编号 1、2 的学生的班级编号都为 1）进行删除操作，则会发生什么事情？

数据库中的数据如下：

测试删除编号为 1 的学生：

HibernateTemplate<Student> hibernateTemplate = new HibernateTemplate<Student>();hibernateTemplate.template(new Notify<Student>() {@Overridepublic Student action(Session session) {Student stu=(Student)session.get(Student.class, new Integer(1));session.delete(stu);return stu;}});

进入 MySql，查看一下：