hualicc 2010-04-04
级联(Cascade):二个以上的设备通过某种方式连接起来,能起到扩容的效果就是级联。Hibernate级联(Cascade)是用来说明数据库中两个表之间相互关系(一对一,一对多,多对多)中,当对主对象进行某种操作时,是否对其关联的从对象也作类似的操作(比如有对象Department和Employee,它们之间是一对多的关系,当保存Department时,其对应的Employee是否也相应的保存),常见的级联(Cascade)有:
(1)none:在保存,删除或修改当前对象时,不对其附属对象(关联对象)进行级联操作。它是默认值。
(2)save-update:在保存,更新当前对象时,级联保存,更新附属对象(临时对象,游离对象)。
(3)delete:在删除当前对象时,级联删除附属对象。
(4)all:所有情况下均进行级联操作,即包含save-update和delete等等操作。
(5)delete-orphan:删除此对象的同时删除与当前对象解除关系的孤儿对象(仅仅使用于一对多关联关系中)。对Hibernate session的每一个基本操作,如:persist(),merge(),saveOrUpdate(),delete(),lock(),refresh(),evict(),replicate(),都有一个相关的级联形式与之对应,他们分别命名为:create,merge,save-update,delete,lock,refresh,evict,replicate.如果你想对某种关联操作设置级联,你只要在映射文件中配置即可,如:
<one-to-one name="person" cascade="persist"/>
如果想同时给级联设置多个值,可以如此设置:
<one-to-one name="person" cascade="persist,delete,lock"/>
建议:
1. 一般对<many-to-one>或<many-to-many>关联关系不设置级联(Cascade)操作,级联(Cascade)操作常常被用于<one-to-one>和<one-to-many>.
2. 如果子对象的生命周期与父对象的生命周期是联系在一起的(一致的),可以通过设置级联cascade="all,delete-orphan"来指定它的对象生命周期。
cascade测试程序如下:
1。实体类:
Department如下:
package com.reiyen.hibernate.domain; public class Department { private int id; private String name; private Set<Employee> emps; //setter和getter方法 }
Employee如下:
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 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 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"/> <!-- name="department" 这个名称必须与Employee中的属性名一致. 设置了column="depart_id",默认它会去department中找id与depart_id值相等的对象.如果要找name的值与depart_id相等的对象,则可以设置property-ref="name" --> <many-to-one name="department" column="depart_id" /> </class> </hibernate-mapping>
测试程序如下:
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:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:updateEmployeesetdepart_id=?whereid=?
Hibernate: update Employee set depart_id=? where id=?数据库表中记录如下:
mysql> select * from department;
+----+-----------------+
|id|name|
+----+-----------------+
|1|departmentname|
+----+-----------------+
1rowinset(0.00sec)
mysql>select*fromemployee;
+----+-----------------+-----------+
|id|name|depart_id|
+----+-----------------+-----------+
|1|employee1name1|1|
|2|employee2name2|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测试程序如下:
测试类如下:
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:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:insertintoDepartment(name)values(?)
Hibernate:updateEmployeesetname=?,depart_id=?whereid=?
Hibernate:updateEmployeesetname=?,depart_id=?whereid=?
Hibernate:updateEmployeesetdepart_id=?whereid=?
Hibernate: update Employee set depart_id=? where id=?2。如果将测试程序中的标记为1,2的语句注释掉,或将标记为3的语句注释掉再进行测试,控制台打印的结果就会少两条update语句,如下所示(此时程序的功能与1一致,数据库中记录也一样,只是此时在对象模型上不是完整的而已,因为在对象模型上,只是告诉了一方与另一方的关系,而反过为,另一方则不知他对应的对象了。其实这对程序没有任何影响):
Hibernate: insert into Employee (name, depart_id) values (?, ?)
Hibernate:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:insertintoDepartment(name)values(?)
Hibernate:updateEmployeesetname=?,depart_id=?whereid=?
Hibernate: update Employee set name=?, depart_id=? where id=?3。 或者将标记为5的语句注释掉,同时将标记为4的语句的注释去掉,再运行;结果与2。的一样只打印两条update语句。但这两条update语句与2中的不同,因为这两条语句是由于
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语句如下所示:
Hibernate: insert into Department (name) values (?)
Hibernate:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:insertintoEmployee(name,depart_id)values(?,?)
Hibernate:updateEmployeesetdepart_id=?whereid=?
Hibernate: update Employee set depart_id=? where id=?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:insertintoEmployee(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:insertintoEmployee(name,depart_id)values(?,?)
Hibernate: insert into Department (name) values (?)没有了更新外键的update语句了。同时查看数据库表中记录,employee表中depart_id的值为null了,如下所示:
mysql> select * from department;
+----+-----------------+
|id|name|
+----+-----------------+
|1|departmentname|
+----+-----------------+
1rowinset(0.00sec)
mysql>select*fromemployee;
+----+-----------------+-----------+
|id|name|depart_id|
+----+-----------------+-----------+
|1|employee1name1|NULL|
|2|employee2name2|NULL|
+----+-----------------+-----------+
2 rows in set (0.00 sec)但可以将测试程序中标记为3的语句(也即建立Department与Employee之间关系的语句)注释掉,再重新运行,结果不会有什么影响,因为现在Department已不再维护关联关系了,所以这句程序要与不要没有区别。
5。如果将上面程序中的set集合映射改成list集合映射来进行(set集合改成list集合映射的细节请参看我写的hibernate集合类(Collections)映射,除了修改映射文件外,还得修改测试程序),在list集合映射中设置级联,如下所示:
<list name="emps" inverse="true"> <key column="depart_id" /> <!-- list-index:用来记录加入list集合的元素的顺序 ,会一定程度影响性能,所以可以使用bag替代list--> <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.