Hibernate下的Many-to-Many的级联删除

hibernate下的Many-to-Many的级联删除

Hibernate多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立

老师Teacher 与 课程Course 是一个多对多的关系，Pojo与XMl配置如下。

 1 /** 
 2  * Course Entity 
 3  * see table: tbl_course 
 4  */  
 5 package com.leo.domain;  
 6   
 7 import java.util.HashSet;  
 8 import java.util.Set;  
 9   
10 /** 
11  * @author superleo 
12  *  
13  */  
14 public class Course {  
15   
16     private String id;  
17   
18     private String name;  
19   
20     private Set<Teacher> teachers = new HashSet<Teacher>();  
21   
22     public String getId() {  
23         return id;  
24     }  
25   
26     public void setId(String id) {  
27         this.id = id;  
28     }  
29   
30     public String getName() {  
31         return name;  
32     }  
33   
34     public void setName(String name) {  
35         this.name = name;  
36     }  
37   
38     public Set<Teacher> getTeachers() {  
39         return teachers;  
40     }  
41   
42     public void setTeachers(Set<Teacher> teachers) {  
43         this.teachers = teachers;  
44     }  
45   
46 }  

 1 /** 
 2  * Teacher Entity 
 3  * see table: tbl_teacher 
 4  */  
 5 package com.leo.domain;  
 6   
 7 import java.util.HashSet;  
 8 import java.util.Set;  
 9   
10 /** 
11  * @author superleo 
12  *  
13  */  
14 public class Teacher {  
15   
16     private String id;  
17   
18     private String name;  
19   
20     private Set<Course> courses = new HashSet<Course>();  
21   
22     public String getId() {  
23         return id;  
24     }  
25   
26     public void setId(String id) {  
27         this.id = id;  
28     }  
29   
30     public String getName() {  
31         return name;  
32     }  
33   
34     public void setName(String name) {  
35         this.name = name;  
36     }  
37   
38     public Set<Course> getCourses() {  
39         return courses;  
40     }  
41   
42     public void setCourses(Set<Course> courses) {  
43         this.courses = courses;  
44     }  
45   
46 }  

配置文件也非常简单：

 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   
 6 <hibernate-mapping>  
 7     <class name="com.leo.domain.Course" table="tbl_course"  
 8         batch-size="100" dynamic-insert="true" dynamic-update="true">  
 9         <id name="id" column="id">  
10             <generator class="uuid" />  
11         </id>  
12         <property name="name" column="name" type="string" />  
13   
14         <set access="property" lazy="true" inverse="false"  
15             cascade="save-update" name="teachers" batch-size="10" fetch="select"  
16             table="tbl_teacher_course">  
17             <key column="fk_course_id" />  
18             <many-to-many class="com.leo.domain.Teacher"  
19                 column="fk_teacher_id" />  
20         </set>  
21   
22     </class>  
23 </hibernate-mapping> 

Xml代码  

 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   
 6 <hibernate-mapping>  
 7     <class name="com.leo.domain.Teacher" table="tbl_teacher"  
 8         batch-size="100" dynamic-insert="true" dynamic-update="true">  
 9         <id name="id" column="id">  
10             <generator class="uuid" />  
11         </id>  
12         <property name="name" column="name" type="string" />  
13   
14         <set access="property" lazy="true" inverse="true"  
15             cascade="save-update" name="courses" batch-size="10" fetch="select"  
16             table="tbl_teacher_course">  
17             <key column="fk_teacher_id" />  
18             <many-to-many class="com.leo.domain.Course"  
19                 column="fk_course_id" />  
20         </set>  
21   
22     </class>  
23 </hibernate-mapping>  

先往数据库里插入一些记录：

 1 public void testSave() {  
 2         Session session = HibernateSessionFactory.getSession();  
 3         session.beginTransaction();  
 4   
 5         // create course  
 6         Course c1 = new Course();  
 7         Course c2 = new Course();  
 8         c1.setName("C");  
 9         c2.setName("Java");  
10   
11         // create teacher  
12         Teacher t1 = new Teacher();  
13         Teacher t2 = new Teacher();  
14         t1.setName("Leo");  
15         t2.setName("Rose");  
16   
17         // create relationship  
18         c1.getTeachers().add(t1);  
19         c1.getTeachers().add(t2);  
20         t1.getCourses().add(c1);  
21         t2.getCourses().add(c1);  
22   
23         /* 因为主控方级联设置为save-update,如果设置为none,则下面被注释的代码需要开启，否则会报错 */  
24         //session.save(t1);   
25         //session.save(t2);  
26         session.save(c1);  
27   
28         session.getTransaction().commit();  
29         session.close();  
30     }  

下面是测试的一些结果：

1. 如果cascade不管主控方设置还是被控方设置成 all, delete等与delete级联删除有关即可，两端以及中间表的记录都会被删除，通常这样的需要是很少的，因此，如果你要这样的情况，只要简单设置成all, delete就可以轻松的将关系以及两端的记录删除的干干净净。

2. 只想删除某一端的记录以及中间的表的关联信息。 这种需求通常是很常见的。这个时候cascade的设置是除与delete有关的任何级联约束。以下是删除心得：

• 如果删除的是主控方，只需要简单的删除这条记录，级联关系以及主控方的记录同时删除，但被控方的记录仍然存在。因此只对主控方的多对多删除是最简单，直接的。代码如下：

 1 /** 
 2      * 多对多 主控方删除(可以删除中间表记录) 
 3      */  
 4     public void testDelete() {  
 5         String id = "402881ee175f04be01175f04c05d0001";  
 6         Session session = HibernateSessionFactory.getSession();  
 7         session.beginTransaction();  
 8         Course c1 = (Course) session.get(Course.class, id);  
 9         session.delete(c1);  
10         session.getTransaction().commit();  
11         session.close();  
12     }  

如果你这个时候想直接删除被控方，那么很遗憾的告诉你，你只做到了一半，你只是简单的把被控方的记录删除了，关联关系仍然存在中间表里，系统随时会因为你的关联访问报错，代码如下：

 1 /** 
 2  * 多对多 被控方删除(无法删除中间表记录) 
 3  */  
 4 public void testDeleteByInverse() {  
 5     String id = "402881ee175a2e7c01175a2e7ead0003";  
 6     Session session = HibernateSessionFactory.getSession();  
 7     session.beginTransaction();  
 8     Teacher t1 = (Teacher) session.get(Teacher.class, id);  
 9     session.delete(t1);  
10     session.getTransaction().commit();  
11     session.close();  
12 }  

如果想既想删除被控方，双想删除关联，请看下面代码：

 1 /** 
 2  * 多对多 被控方删除(可以删除中间表记录) 
 3  */  
 4 public void testDeleteByInverse2() {  
 5     String id = "402881ee175f04be01175f04c06c0002";  
 6     Session session = HibernateSessionFactory.getSession();  
 7     session.beginTransaction();  
 8   
 9     Teacher t1 = (Teacher) session.get(Teacher.class, id);  
10   
11     Set<Course> cs = t1.getCourses();  
12     for (Course c : cs) {  
13         c.getTeachers().remove(t1);  
14     }  
15   
16     session.delete(t1);  
17     session.getTransaction().commit();  
18     session.close();  
19 }  

完成了。 但如果是Spring+Hiberante下多对多删除，可能会报一个错误，目前的解决办法是把两端的cascade都设置成none. 初步断定可能与事务有关，如果有人遇到了，并知道为什么，希望能留言，先谢谢大家了。

 

注：三个表的表结构

1. tbl_course.sql

1   create table "SCOTT"."TBL_COURSE"(
2         "ID" VARCHAR2(80) not null,
3        "NAME" VARCHAR2(20) not null,
4         constraint "SYS_C005315" primary key ("ID")
5     );
6 
7 create unique index "SCOTT"."SYS_C005315" on "SCOTT"."TBL_COURSE"("ID");

2. tbl_teacher.sql

1 create table "SCOTT"."TBL_TEACHER"(
2         "ID" VARCHAR2(80) not null,
3        "NAME" VARCHAR2(20) not null,
4         constraint "SYS_C005313" primary key ("ID")
5     );
6 
7 create unique index "SCOTT"."SYS_C005313" on "SCOTT"."TBL_TEACHER"("ID");

3.tbl_teacher_course.sql

1   create table "SCOTT"."TBL_TEACHER_COURSE"(
2         "FK_TEACHER_ID" VARCHAR2(80),
3        "FK_COURSE_ID" VARCHAR2(90)
4     );