Hibernate多对多删除

原创 2010年06月02日 23:49:00

老师Teacher 与 课程Course 是一个多对多的关系,Pojo与XMl配置如下。
Pojo
Java代码
/** 
 * Course Entity 
 * see table: tbl_course 
 */ 
package com.leo.domain;  
import java.util.HashSet;  
import java.util.Set;  
public class Course {  
    private String id;  
    private String name;  
    private Set<Teacher> teachers = new HashSet<Teacher>();    
    public String getId() {  
        return id;  
    }   
    public void setId(String id) {  
        this.id = id;  
    }    
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }   
    public Set<Teacher> getTeachers() {  
        return teachers;  
    }    
    public void setTeachers(Set<Teacher> teachers) {  
        this.teachers = teachers;  
    }  

/**
 * Course Entity
 * see table: tbl_course
 */
package com.leo.domain;
import java.util.HashSet;
import java.util.Set;
public class Course {
 private String id;
 private String name;
 private Set<Teacher> teachers = new HashSet<Teacher>();

 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Set<Teacher> getTeachers() {
  return teachers;
 }
 public void setTeachers(Set<Teacher> teachers) {
  this.teachers = teachers;
 }
}
Java代码
/** 
 * Teacher Entity 
 * see table: tbl_teacher 
 */ 
package com.leo.domain;  
 
import java.util.HashSet;  
import java.util.Set;   
public class Teacher {  
    private String id;  
    private String name;  
    private Set<Course> courses = new HashSet<Course>();  
    public String getId() {  
        return id;  
    }  
    public void setId(String id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public Set<Course> getCourses() {  
        return courses;  
    }  
    public void setCourses(Set<Course> courses) {  
        this.courses = courses;  
    }    } 
/**
 * Teacher Entity
 * see table: tbl_teacher
 */
package com.leo.domain;
import java.util.HashSet;
import java.util.Set;
public class Teacher {
 private String id;
 private String name;
 private Set<Course> courses = new HashSet<Course>();
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Set<Course> getCourses() {
  return courses;
 }
 public void setCourses(Set<Course> courses) {
  this.courses = courses;
 }}
 配置文件也非常简单:
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> 
    <class name="com.leo.domain.Course" table="tbl_course" 
        batch-size="100" dynamic-insert="true" dynamic-update="true"> 
        <id name="id" column="id"> 
            <generator class="uuid" /> 
        </id> 
        <property name="name" column="name" type="string" />  
        <set access="property" lazy="true" inverse="false" 
            cascade="save-update" name="teachers" batch-size="10" fetch="select" 
            table="tbl_teacher_course"> 
            <key column="fk_course_id" /> 
            <many-to-many class="com.leo.domain.Teacher" 
                column="fk_teacher_id" /> 
        </set>  
    </class> 
</hibernate-mapping> 
<?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>
 <class name="com.leo.domain.Course" table="tbl_course"
  batch-size="100" dynamic-insert="true" dynamic-update="true">
  <id name="id" column="id">
   <generator class="uuid" />
  </id>
  <property name="name" column="name" type="string" />
  <set access="property" lazy="true" inverse="false"
   cascade="save-update" name="teachers" batch-size="10" fetch="select"
   table="tbl_teacher_course">
   <key column="fk_course_id" />
   <many-to-many class="com.leo.domain.Teacher"
    column="fk_teacher_id" />
  </set>
 </class>
</hibernate-mapping>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> 
    <class name="com.leo.domain.Teacher" table="tbl_teacher" 
        batch-size="100" dynamic-insert="true" dynamic-update="true"> 
        <id name="id" column="id"> 
            <generator class="uuid" /> 
        </id> 
        <property name="name" column="name" type="string" />  
        <set access="property" lazy="true" inverse="true" 
            cascade="save-update" name="courses" batch-size="10" fetch="select" 
            table="tbl_teacher_course"> 
            <key column="fk_teacher_id" /> 
            <many-to-many class="com.leo.domain.Course" 
                column="fk_course_id" /> 
        </set> 
    </class> 
</hibernate-mapping> 
<?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>
 <class name="com.leo.domain.Teacher" table="tbl_teacher"
  batch-size="100" dynamic-insert="true" dynamic-update="true">
  <id name="id" column="id">
   <generator class="uuid" />
  </id>
  <property name="name" column="name" type="string" />

  <set access="property" lazy="true" inverse="true"
   cascade="save-update" name="courses" batch-size="10" fetch="select"
   table="tbl_teacher_course">
   <key column="fk_teacher_id" />
   <many-to-many class="com.leo.domain.Course"
    column="fk_course_id" />
  </set>
 </class>
</hibernate-mapping>
先往数据库里插入一些记录:
Java代码
public void testSave() {  
        Session session = HibernateSessionFactory.getSession();  
        session.beginTransaction();  
        // create course  
        Course c1 = new Course();  
        Course c2 = new Course();  
        c1.setName("C");  
        c2.setName("Java");  
        // create teacher  
        Teacher t1 = new Teacher();  
        Teacher t2 = new Teacher();  
        t1.setName("Leo");  
        t2.setName("Rose");   
        // create relationship  
        c1.getTeachers().add(t1);  
        c1.getTeachers().add(t2);  
        t1.getCourses().add(c1);  
        t2.getCourses().add(c1);  
        /* 因为主控方级联设置为save-update,如果设置为none,则下面被注释的代码需要开启,否则会报错 */ 
        //session.save(t1);   
        //session.save(t2);  
        session.save(c1);  
        session.getTransaction().commit();  
        session.close();  
    } 
public void testSave() {
  Session session = HibernateSessionFactory.getSession();
  session.beginTransaction();
  // create course
  Course c1 = new Course();
  Course c2 = new Course();
  c1.setName("C");
  c2.setName("Java");
  // create teacher
  Teacher t1 = new Teacher();
  Teacher t2 = new Teacher();
  t1.setName("Leo");
  t2.setName("Rose");
  // create relationship
  c1.getTeachers().add(t1);
  c1.getTeachers().add(t2);
  t1.getCourses().add(c1);
  t2.getCourses().add(c1);
  /* 因为主控方级联设置为save-update,如果设置为none,则下面被注释的代码需要开启,否则会报错 */
  //session.save(t1);
  //session.save(t2);
  session.save(c1);
  session.getTransaction().commit();
  session.close();
 }
下面是测试的一些结果:
1. 如果cascade不管主控方设置还是被控方设置成 all, delete等与delete级联删除有关即可,两端以及中间表的记录都会被删除,通常这样的需要是很少的,因此,如果你要这样的情况,只要简单设置成all, delete就可以轻松的将关系以及两端的记录删除的干干净净。
2. 只想删除某一端的记录以及中间的表的关联信息。 这种需求通常是很常见的。这个时候cascade的设置是除与delete有关的任何级联约束。以下是删除心得:
如果删除的是主控方,只需要简单的删除这条记录,级联关系以及主控方的记录同时删除,但被控方的记录仍然存在。因此只对主控方的多对多删除是最简单,直接的。代码如下:Java代码
/** 
     * 多对多 主控方删除(可以删除中间表记录) 
     */ 
    public void testDelete() {  
        String id = "402881ee175f04be01175f04c05d0001";  
        Session session = HibernateSessionFactory.getSession();  
        session.beginTransaction();  
        Course c1 = (Course) session.get(Course.class, id);  
        session.delete(c1);  
        session.getTransaction().commit();  
        session.close();  
    } 
/**
  * 多对多 主控方删除(可以删除中间表记录)
  */
 public void testDelete() {
  String id = "402881ee175f04be01175f04c05d0001";
  Session session = HibernateSessionFactory.getSession();
  session.beginTransaction();
  Course c1 = (Course) session.get(Course.class, id);
  session.delete(c1);
  session.getTransaction().commit();
  session.close();
 }
如果你这个时候想直接删除被控方,那么很遗憾的告诉你,你只做到了一半,你只是简单的把被控方的记录删除了,关联关系仍然存在中间表里,系统随时会因为你的关联访问报错,代码如下:Java代码
/** 
 * 多对多 被控方删除(无法删除中间表记录) 
 */ 
public void testDeleteByInverse() {  
    String id = "402881ee175a2e7c01175a2e7ead0003";  
    Session session = HibernateSessionFactory.getSession();  
    session.beginTransaction();  
    Teacher t1 = (Teacher) session.get(Teacher.class, id);  
    session.delete(t1);  
    session.getTransaction().commit();  
    session.close();  

 /**
  * 多对多 被控方删除(无法删除中间表记录)
  */
 public void testDeleteByInverse() {
  String id = "402881ee175a2e7c01175a2e7ead0003";
  Session session = HibernateSessionFactory.getSession();
  session.beginTransaction();
  Teacher t1 = (Teacher) session.get(Teacher.class, id);
  session.delete(t1);
  session.getTransaction().commit();
  session.close();
 }
如果想既想删除被控方,双想删除关联,请看下面代码:Java代码
/** 
 * 多对多 被控方删除(可以删除中间表记录) 
 */ 
public void testDeleteByInverse2() {  
    String id = "402881ee175f04be01175f04c06c0002";  
    Session session = HibernateSessionFactory.getSession();  
    session.beginTransaction();  
    Teacher t1 = (Teacher) session.get(Teacher.class, id);  
    Set<Course> cs = t1.getCourses();  
    for (Course c : cs) {  
        c.getTeachers().remove(t1);  
    }  
    session.delete(t1);  
    session.getTransaction().commit();  
    session.close();  

 /**
  * 多对多 被控方删除(可以删除中间表记录)
  */
 public void testDeleteByInverse2() {
  String id = "402881ee175f04be01175f04c06c0002";
  Session session = HibernateSessionFactory.getSession();
  session.beginTransaction();

  Teacher t1 = (Teacher) session.get(Teacher.class, id);

  Set<Course> cs = t1.getCourses();
  for (Course c : cs) {
   c.getTeachers().remove(t1);
  }

  session.delete(t1);
  session.getTransaction().commit();
  session.close();
 }
完成了。 但如果是Spring+Hiberante下多对多删除,可能会报一个错误,目前的解决办法是把两端的cascade都设置成none. 初步断定可能与事务有关,如果有人遇到了,并知道为什么,希望能留言,先谢谢大家了。
注:三个表的表结构
1. tbl_course.sql
    create table "SCOTT"."TBL_COURSE"(
        "ID" VARCHAR2(80) not null,
       "NAME" VARCHAR2(20) not null,
        constraint "SYS_C005315" primary key ("ID")
    );
create unique index "SCOTT"."SYS_C005315" on "SCOTT"."TBL_COURSE"("ID");
2. tbl_teacher.sql
    create table "SCOTT"."TBL_TEACHER"(
        "ID" VARCHAR2(80) not null,
       "NAME" VARCHAR2(20) not null,
        constraint "SYS_C005313" primary key ("ID")
    );
create unique index "SCOTT"."SYS_C005313" on "SCOTT"."TBL_TEACHER"("ID");
3.tbl_teacher_course.sql
  create table "SCOTT"."TBL_TEACHER_COURSE"(
        "FK_TEACHER_ID" VARCHAR2(80),
       "FK_COURSE_ID" VARCHAR2(90)
    );
===========================================================
只删除中间表,可以通过以下代码。
/**
* 多对多 通过主控方删除中间表(其余记录都不变)
*/
public void testDeleteByInverse3() {
String id = "402881ee1782dad9011782dadb310001";
Session session = HibernateSessionFactory.getSession();
session.beginTransaction();

Course c1 = (Course) session.get(Course.class, id);
c1.setTeachers(null);

session.getTransaction().commit();
session.close();
}
/**
* 多对多 通过被控方删除中间表(其余记录都不变)
*/
public void testDeleteByInverse4() {
String id = "402881ee1782dbd4011782dbd64a0002";
Session session = HibernateSessionFactory.getSession();
session.beginTransaction();
Teacher t1 = (Teacher) session.get(Teacher.class, id);
Set<Course> cs = t1.getCourses();
for (Course c : cs) {
c.getTeachers().remove(t1);
}
session.getTransaction().commit();
session.close();
}

hibernate 多对多删除解决方案

hibernate多对多当中,我们常常希望只删除一方已及对应的关系,但不想删除另一方,怎么样达到呢? (这里只提删除)表user和表role多对多,中间表user_role(userId,roleId...
  • daijunjieok
  • daijunjieok
  • 2010-11-19 21:48:00
  • 10235

Hibernate多对多级联删除的问题

当数据库两个表是多对多关联关系的时候,维护者应该是数据量较少的一方。 即维护者inverse=false,被维护者inverse = true。 级联关系建议都是cascade= save-upd...
  • Julyraining
  • Julyraining
  • 2015-10-11 16:22:43
  • 2398

hibernate多对多关系配置--增删改查

hibernate多对多关联配置--并实现增删改查          hibernate就不多介绍了,这里就直接上我项目中使用的例子做说明。          数据模型 这是项目中用...
  • cb2474600377
  • cb2474600377
  • 2016-04-08 10:19:06
  • 4326

hibernate多对多增删改查

Hibernate多对多增删改查JavaEE2010-06-05 12:09:34阅读16评论0字号:大中小package com.qulx.client;import java.util.Itera...
  • elfenliedef
  • elfenliedef
  • 2010-07-22 16:50:00
  • 572

hibernate 多对多只删除中间表数据

首先配置表的多对多映射 具体方法参见《深入浅出hibernate》  下面列出删除中间表数据的方法  role跟Program 是多对多关系  Java代码   Role ...
  • yztezhl
  • yztezhl
  • 2013-08-09 09:40:22
  • 3526

Hibernate 一对多级联删除

实例一 背景: 系统中有post表和replay表。分表表示帖子和帖子回复的表。一篇帖子可以有多个回复。   要求:     现在要求删除一篇帖子的同时删除对应的repl...
  • z69183787
  • z69183787
  • 2014-02-27 11:08:40
  • 6300

<em>Hibernate</em>_一<em>对多</em>增删改查数据

经典的,这也是我学习过程中的心得,希望大家能给我指点,也希望大家多上传资料...<em>hibernate</em>一<em>对多</em>,更新主表时<em>删除</em>旧的多方数据加入新的多方数据 <em>Hibernate</em> 单向...
  • 2018年04月16日 00:00

hibernate中多对一映射删除

package com.hibernate1.entity; import org.hibernate.Session; import org.hibernate.SessionFacto...
  • pangqiandou
  • pangqiandou
  • 2016-11-27 17:53:15
  • 531

关于hibernate的多对多查询、删除、修改

一:多对多 用MyEclipse反转生成多对多的关系时,中间的关联表不要建自己自增长标示列,在next后面勾选enable many tomany 可以生成多对多的关系,相对来说多对多的hql语句更...
  • u013666974
  • u013666974
  • 2014-02-14 22:12:32
  • 1081
收藏助手
不良信息举报
您举报文章:Hibernate多对多删除
举报原因:
原因补充:

(最多只允许输入30个字)