【SSH三大框架】Hibernate基础第九篇：cascade关联关系的级联操作

 

【SSH三大框架】Hibernate基础第九篇：cascade关联关系的级联操作

分类： SSH 2014-11-18 10:24  534人阅读  评论(0)  收藏  举报

cascade 级联

这里要说的是Hibernate的关联关系的级联操作，使用cascade属性控制。

依然用部门和员工举例，多个员工对应一个部门（多对一关联关系）

员工类：Employee.java

[java]  view plain copy print ?

1. package cn.itcast.hibernate.domain;  
2.   
3. public class Employee {    
4.     private int id;    
5.     private String name;    
6.     private Department depart;    
7.         
8.     public int getId() {    
9.         return id;    
10.     }    
11.     public void setId(int id) {    
12.         this.id = id;    
13.     }    
14.     public String getName() {    
15.         return name;    
16.     }    
17.     public void setName(String name) {    
18.         this.name = name;    
19.     }    
20.     public Department getDepart() {    
21.         return depart;    
22.     }    
23.     public void setDepart(Department depart) {    
24.         this.depart = depart;    
25.     }    
26. }    

员工类映射文件：Employee.hbm.xml

[java]  view plain copy print ?

1. <?xml version="1.0"?>    
2. <!DOCTYPE hibernate-mapping PUBLIC     
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
5. <hibernate-mapping     
6.     package="cn.itcast.hibernate.domain">    
7.     <class name="Employee" table="tb_Employee">    
8.         <id name="id">    
9.             <generator class="native"/>     
10.         </id>    
11.         <property name="name" />    
12.         <many-to-one name="depart" column="depart_id" />    
13.     </class>    
14.         
15. </hibernate-mapping>    

部门类：Department.java

[java]  view plain copy print ?

1. package cn.itcast.hibernate.domain;  
2.   
3. import java.util.Set;  
4.   
5. public class Department {    
6.     private int id;    
7.     private String name;    
8.     private Set<Employee> emps;  
9.       
10.     public Set<Employee> getEmps() {  
11.         return emps;  
12.     }  
13.     public void setEmps(Set<Employee> emps) {  
14.         this.emps = emps;  
15.     }  
16.     public int getId() {    
17.         return id;    
18.     }    
19.     public void setId(int id) {    
20.         this.id = id;    
21.     }    
22.     public String getName() {    
23.         return name;    
24.     }    
25.     public void setName(String name) {    
26.         this.name = name;    
27.     }    
28. }    

部门映射文件：Department.hbm.xml

[html]  view plain copy print ?

1. <?xml version="1.0"?>    
2. <!DOCTYPE hibernate-mapping PUBLIC     
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    
4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">    
5. <hibernate-mapping     
6.     package="cn.itcast.hibernate.domain">    
7.     
8.     <class name="Department" table="tb_Department">    
9.         <id name="id">    
10.             <generator class="native"/>     
11.         </id>    
12.         <property name="name" />    
13.           
14.         <set name="emps" cascade="save-update">  
15.             <key column="depart_id" />  
16.             <one-to-many class="Employee" />  
17.         </set>  
18.     </class>    
19.         
20. </hibernate-mapping>    

可以看到，在上边的set标签中，我们定义了cascade="save-update"属性，当session通过save(),update(),saveOrUpdate()方法来保存或更新对象时，级联保存所有关联的新建的临时对象，并且级联更新所有关联的游离对象

我们来写一个测试类：Many2One.java

[java]  view plain copy print ?

1. package cn.itcast.hibernate;  
2.   
3. import java.util.HashSet;  
4. import java.util.Set;  
5.   
6. import org.hibernate.Hibernate;  
7. import org.hibernate.Session;  
8. import org.hibernate.Transaction;  
9.   
10. import cn.itcast.hibernate.domain.Department;  
11. import cn.itcast.hibernate.domain.Employee;  
12.   
13. public class Many2One {    
14.     public static void main(String[] arg){    
15.         Department depart = add();    
16.     
17.         delete(1);  
18.     }    
19.         
20.     static Department add(){    
21.         Session s = null;    
22.         Transaction tx = null;    
23.         try{    
24.             Department depart = new Department();   
25.       
26.             depart.setName("depart name");    
27.                 
28.             Employee emp1 = new Employee();    
29.             emp1.setDepart(depart); //建立两个对象的关联关系    
30.             emp1.setName("emp name");    
31.               
32.               
33.             Employee emp2 = new Employee();    
34.             emp2.setDepart(depart); //建立两个对象的关联关系    
35.             emp2.setName("emp name");    
36.               
37.       
38.             Set<Employee> emps = new HashSet<Employee>();  
39.             //把两个Employee对象添加到set集合中  
40.             emps.add(emp1);  
41.             emps.add(emp2);  
42.             //为Department对象注入set集合属性  
43.             depart.setEmps(emps);  
44.               
45.             s = HibernateUtil.getSession();    
46.             tx = s.beginTransaction();    
47.              
48.             //保存Department对象  
49.             s.save(depart);   
50.               
51.             tx.commit();    
52.             return depart;    
53.         }finally{    
54.             if(s!=null){    
55.                 s.close();    
56.             }    
57.         }    
58.     }    
59.         
60.     static Department delete(int departId){    
61.         Session s = null;    
62.         Transaction tx = null;    
63.         try{    
64.             s = HibernateUtil.getSession();    
65.             tx = s.beginTransaction();    
66.             Department depart = (Department)s.get(Department.class, departId); //根据ID查询    
67.             s.delete(depart);  
68.               
69.             tx.commit();    
70.             return depart;    
71.         }finally{    
72.             if(s!=null){    
73.                 s.close();    
74.             }    
75.         }    
76.     }    
77. }    

可以看到我们定义了两个方法：add()和delete()

add()：在这个方法中，我们在保存的时候仅仅保存了Department对象，但是根据cascade="save-update"属性，两个Employee对象也会保存在数据库中

delete()：在这个方法中，我们想通过直接删除Department对象使得数据库中与Department表关联的Employee表中的数据删除。但是，我们配置的cascade是要求在保存或者更新的时候发生级联关系，所以如果我们执行delete()方法后，只会在Department表的数据被删除，Employee表的数据的外键会变成null，但是数据不会被删除

下边我们来看下cascade的取值：

Cascade属性的取值有：

1、none：忽略其他关联的对象，默认值。

2、save-update：当session通过save(),update(),saveOrUpdate()方法来保存或更新对象时，级联保存所有关联的新建的临时对象，并且级联更新所有关联的游离对象。

3、persist：当session通过persist()方法来保存当前对象时，会级联保存所有关联的新建的临时对象。

4、merge：通过Session的merge()方法来保存当前对象时，会级联融合所有关联的游离对象。

5、delete：通过delete()删除当前对象时，会级联删除所有关联的对象。

6、lock：通过lock()把当前游离对象加入session缓存时，会把所有的游离对象也加入Session缓存中。

7、replicate:通过replicate()复制当前对象时，会级联复制所有关联的对象。

8、evict:通过evict()清除session缓存中对象时，会级联清除所有关联的对象。

9、refresh:通过refresh()刷新当前对象时，会级联刷新所有关联的对象。(刷新是指同步更新session缓存中数据)

10、all:save-update(),persist(),merge(),delete(),lock(),replicate(),evict()及refresh()的行为。

11、delete-orphan,删除所有和当前对象时，解除关联行为的对象。

12、all-delete-orphan; 通过delete()删除当前对象时，会级联删除所有关联的对象。