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>() {
            @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. 小结

本节课和大家聊了双向一对多关联映射。

无论是一对一双向关联映射，还是一对多双向关联映射。都可以根据需要随时设置是否延迟加载、级联等操作。

在使用级联操作时，一定要小心，避免产生连锁反应，删除了不应该删除的数据。