hibernate 级联（cascade和inverse）

时间 2019-11-07

标签 hibernate 级联 cascade inverse 栏目 Hibernate 繁體版

原文原文链接

级联（Cascade）：二个以上的设备经过某种方式链接起来，能起到扩容的效果就是级联。Hibernate级联（Cascade）是用来讲明数据库中两个表之间相互关系(一对一,一对多,多对多)中，当对主对象进行某种操做时，是否对其关联的从对象也做相似的操做（好比有对象Department和Employee，它们之间是一对多的关系，当保存Department时，其对应的Employee是否也相应的保存），常见的级联(Cascade)有： mysql

(1)none：在保存，删除或修改当前对象时，不对其附属对象（关联对象）进行级联操做。它是默认值。
(2)save-update：在保存，更新当前对象时，级联保存，更新附属对象(临时对象，游离对象)。
(3)delete：在删除当前对象时，级联删除附属对象。
(4)all：全部状况下均进行级联操做，即包含save-update和delete等等操做。
(5)delete-orphan：删除此对象的同时删除与当前对象解除关系的孤儿对象(仅仅使用于一对多关联关系中)。 sql

对Hibernate session的每个基本操做，如：persist(),merge(),saveOrUpdate(),delete(),lock(),refresh(),evict(),replicate(),都有一个相关的级联形式与之对应，他们分别命名为：create,merge,save-update,delete,lock,refresh,evict,replicate.若是你想对某种关联操做设置级联，你只要在映射文件中配置便可，如：数据库

Xml代码

<one-to-one name="person" cascade="persist"/>

若是想同时给级联设置多个值，能够如此设置： session

Xml代码

<one-to-one name="person" cascade="persist,delete,lock"/>

建议： app

1. 通常对<many-to-one>或<many-to-many>关联关系不设置级联（Cascade）操做，级联（Cascade）操做经常被用于<one-to-one>和<one-to-many>. dom

2. 若是子对象的生命周期与父对象的生命周期是联系在一块儿的（一致的），能够经过设置级联cascade="all,delete-orphan"来指定它的对象生命周期。 ide

cascade测试程序以下：性能

1。实体类：测试

Department以下： this

Java代码

package com.reiyen.hibernate.domain;
public class Department {
private int id;
private String name;
private Set<Employee> emps;
//setter和getter方法
}

Employee以下：

Java代码

package com.reiyen.hibernate.domain;
public class Employee {
private int id;
private String name;
private Department department;
//setter和getter方法
@Override
public String toString() {
return "id=" + this.id + " name=" + this.name;
}
}

映射文件以下：

Department.hbm.xml映射文件以下：

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">
<hibernate-mapping package="com.reiyen.hibernate.domain">
<class name="Department">
<id name="id">
<generator class="native" />
</id>
<property name="name" />
//配置多个cascade值，只需用，分隔便可
<set name="emps" cascade="save-update，delete">
<key column="depart_id" />
<one-to-many class="Employee"/>
</set>
</class>
</hibernate-mapping>

Employee.hbm.xml映射文件以下：

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">
<hibernate-mapping package="com.reiyen.hibernate.domain">
<class name="Employee">
<id name="id">
<generator class="native" />
</id>
<property name="name" unique="true"/>
<many-to-one name="department" column="depart_id" />
</class>
</hibernate-mapping>

测试程序以下：

Java代码

public class One2Many {
public static void main(String[] args) {
Department depart = add();
Department department = queryDepart(depart.getId());
}
static Department queryDepart(int departId) {
Session s = null;
Transaction tx = null;
try {
s = HibernateUtil.getSession();
tx = s.beginTransaction();
Department depart = (Department) s.get(Department.class, departId);
System.out.println("emps:" + depart.getEmps());
tx.commit();
return depart;
} finally {
if (s != null)
s.close();
}
}
static Department add() {
Session s = null;
Transaction tx = null;
try {
Department depart = new Department();
depart.setName("department name");
Employee employee1 = new Employee();
employee1.setName("employee1 name1");
Employee employee2 = new Employee();
employee2.setName("employee2 name2");
Set<Employee> set = new HashSet<Employee>();
set.add(employee1);
set.add(employee2);
depart.setEmps(set);
s = HibernateUtil.getSession();
tx = s.beginTransaction();
s.save(depart);
//s.save(employee1); //1
//s.save(employee2); //2
tx.commit();
return depart;
} finally {
if (s != null)
s.close();
}
}
}

由于在映射文件Department.hbm.xml文件中给集合映射set配置了级联(cascade="save-update"),因此将测试程序中注释为1，2的两句程序（保存set集合中Employee元素的程序）注释掉，程序也同样能将这两个Employee元素保存进数据库中，测试结果以下所示：

控制台打印信息以下：

Hibernate: insert into Department (name) values (?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: update Employee set depart_id=? where id=?
Hibernate: update Employee set depart_id=? where id=?

数据库表中记录以下：

mysql> select * from department;
+----+-----------------+
| id | name            |
+----+-----------------+
| 1 | department name |
+----+-----------------+
1 row in set (0.00 sec)

mysql> select * from employee;
+----+-----------------+-----------+
| id | name            | depart_id |
+----+-----------------+-----------+
| 1 | employee1 name1 |         1 |
| 2 | employee2 name2 |         1 |
+----+-----------------+-----------+
2 rows in set (0.00 sec)

若是Department映射文件中的set集合映射没有设置级联，一样的程序进行测试，则会抛出以下异常，控制台打印信息以下：

Hibernate: insert into Department (name) values (?)
Hibernate: update Employee set depart_id=? where id=?

org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: com.reiyen.hibernate.domain.Employee

当把Department实例持久化进数据库后，更新它相关联的Employee对象时抛出异常，由于此时关联的Employee是瞬时对象，而不是一个持久化对象。

inverse: 表示“是否放弃维护关联关系”（在Java里两个对象产生关联时，对数据库中表的影响）,hibernate的缺省值为false。在<one-to-many>和<many-to-many>关联关系的集合定义中使用,inverse="true"表示该对象不维护关联关系。该属性的值在使用有序集合时（list,array等）时通常设置为false.<one-to-many>维护关联关系就是更新外键；<many-to-many>维护关联关系就是在中间表中增减记录！

cascade 和inverse有什么区别？能够这样理解，cascade 定义的是关系两端对象到对象的级联关系；而inverse定义的是关系和对象的级联关系。

inverse测试程序以下：

测试类以下：

Java代码

public class One2Many {
public static void main(String[] args) {
Department depart = add();
Department department = queryDepart(depart.getId());
}
static Department queryDepart(int departId) {
Session s = null;
Transaction tx = null;
try {
s = HibernateUtil.getSession();
tx = s.beginTransaction();
Department depart = (Department) s.get(Department.class, departId);
System.out.println("emps:" + depart.getEmps());
tx.commit();
return depart;
} finally {
if (s != null)
s.close();
}
}
static Department add() {
Session s = null;
Transaction tx = null;
try {
Department depart = new Department();
depart.setName("department name");
Employee employee1 = new Employee();
employee1.setDepartment(depart); //1 对象模型：创建两个对象的关联
employee1.setName("employee1 name1");
Employee employee2 = new Employee();
employee2.setDepartment(depart); //2 对象模型：创建两个对象的关联
employee2.setName("employee2 name2");
Set<Employee> set = new HashSet<Employee>();
set.add(employee1);
set.add(employee2);
depart.setEmps(set); //3 对象模型：创建两个对象的关联
s = HibernateUtil.getSession();
tx = s.beginTransaction();
//s.save(depart); //4
s.save(employee1);
s.save(employee2);
s.save(depart); //5
tx.commit();
return depart;
} finally {
if (s != null)
s.close();
}
}
}

先在Department.hbm.xml文件中不设置inverse进行测试：

1。测试结果以下，控制台打印了四条update语句（这是由于关联对象双方都要去维护这种关联关系所致使的结果）：

Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Department (name) values (?)
Hibernate: update Employee set name=?, depart_id=? where id=?
Hibernate: update Employee set name=?, depart_id=? where id=?
Hibernate: update Employee set depart_id=? where id=?
Hibernate: update Employee set depart_id=? where id=?

2。若是将测试程序中的标记为1,2的语句注释掉，或将标记为3的语句注释掉再进行测试，控制台打印的结果就会少两条update语句，以下所示（此时程序的功能与1一致，数据库中记录也同样，只是此时在对象模型上不是完整的而已，由于在对象模型上，只是告诉了一方与另外一方的关系，而反过为，另外一方则不知他对应的对象了。其实这对程序没有任何影响）：

3。或者将标记为5的语句注释掉，同时将标记为4的语句的注释去掉，再运行;结果与2。的同样只打印两条update语句。但这两条update语句与2中的不一样，由于这两条语句是因为

Java代码

depart.setEmps(set); //3 对象模型：创建两个对象的关联

而产生的。此时为何只有这两条update语句了呢？由于先保存了Department对象，因此再保存Employee时，直接就能够将Department对象的值取到，直接保存在数据库中了，而再也不须要update.因此就少了如下的两条SQL语句:

Hibernate: update Employee set name=?, depart_id=? where id=?
Hibernate: update Employee set name=?, depart_id=? where id=?

.产生的SQL语句以下所示：

4。在cascade程序的基础上进行修改。将Department.hbm.xml文件进行修改，将cascade="save-update,delete"替换成inverse="true"便可，其他的地方保持原样。再继续运行测试程序，这是控制台打印的信息与测试2的结果一致，也只有两打update语句，但此时在对象模型上也是完整的，由于对象模型知道了相互对应的另外一方,此时Department对象已经放弃关联关系的维护了，只有Employee对象去维护他们之间的关联关系，因此只产生了两条update语句。inverse"是否放弃维护关联关系"通常在one的一方设置(其实hibernate不容许多的一端放弃维护关联关系，而由one的一端维护，由于这是很是低效率的)，这比比如一个Teacher与Student这种现实生活中的关系，你让老师记住每一个学生的名字这是比较困难的一件事情，因此你就让老师不用去记学生，而让学生去记老师就好了，这会简单的多，而只要每一个学生记住了老师，这样他们的关联也就能够维持了。同时，这样还能够提升效率。在上例中，当设置了级联关系后，若是先保存Department,再保存Employee(也就是再执行上例中第三种操做)，控制台就不会再产生update语句了。以下所示：

Hibernate: insert into Department (name) values (?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)

但此时有一点须要很是注意：由于你已经设置了让Department对象放弃维护关联关系了，因此此时，测试程序中标记为1,2的语句必定不能少，不然在数据库中就体现不了它们之间的关联关系了。注释掉标记为1，2的两句程序，从新运行，结果以下所示，控制台打印信息以下：

Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate: insert into Department (name) values (?)

没有了更新外键的update语句了。同时查看数据库表中记录，employee表中depart_id的值为null了,以下所示：

但能够将测试程序中标记为3的语句（也即创建Department与Employee之间关系的语句）注释掉，再从新运行，结果不会有什么影响，由于如今Department已再也不维护关联关系了，因此这句程序要与不要没有区别。

5。若是将上面程序中的set集合映射改为list集合映射来进行（set集合改为list集合映射的细节请参看我写的hibernate集合类（Collections）映射，除了修改映射文件外，还得修改测试程序）,在list集合映射中设置级联，以下所示：

Xml代码

<list name="emps" inverse="true">
<key column="depart_id" />
<list-index column="order_col" />
<one-to-many class="Employee" />
</list>

再运行如上的测试程序，则会出现以下的异常：

org.hibernate.HibernateException: null index column for collection: com.reiyen.hibernate.domain.Department.emps

由于在list集合映射中须要维护加入list集合中的元素的顺序，而inverse=“true”是放弃维护关联关系。当对象之间的关联关系都不维护，再谈添加入的顺序，已没有什么意义。因此及在使用hibernate的有序集合时，通常将inverse设置成false.