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>() {
@Override
public 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:
select
student0_.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_
from
Student student0_
left outer join
ClassRoom classroom1_
on student0_.classRoomId=classroom1_.classRoomId
where
student0_.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>() {
@Override
public 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:
select
classroom0_.classRoomId as classRoo1_0_0_,
classroom0_.classRoomDesc as classRoo2_0_0_,
classroom0_.classRoomName as classRoo3_0_0_
from
ClassRoom classroom0_
where
classroom0_.classRoomId=?
班级名称:c1911
------我是分隔线------------------------
Hibernate:
select
students0_.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_
from
Student students0_
where
students0_.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>() {
@Override
public 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>() {
@Override
public 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>() {
@Override
public Student action(Session session) {
Student stu=(Student)session.get(Student.class, new Integer(1));
session.delete(stu);
return stu;
}
});
进入 MySql,查看一下:
天呀!这是级联还是株连呀,太让人后怕,数据都没有了。
删除学生时,会级联删除和学生有关的班级,班级删除时,又会查看学生表中是否还存在与班级有关联的学生,有,则一刀下去,连根拔起。
Hibernate 有点刹不住车,产生了级联连锁反应。
针对上面的测试,如果班级表的级联关闭,执行测试代码,请问结果又会怎样?
本节课程,讲解了级联删除,级联添加的内容留到下节课继续展开。
5. 小结
本文和大家聊了双向一对多关联映射。
无论是一对一双向关联映射,还是一对多双向关联映射。都可以根据需要随时设置是否延迟加载、级联等操作。
在使用级联操作时,一定要小心,避免产生连锁反应,删除了不应该删除的数据。