hibernate many-to-many

最新推荐文章于 2025-07-28 23:27:29 发布
最新推荐文章于 2025-07-28 23:27:29 发布
阅读量950 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： hibernate string session table generator delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wyfh2010/article/details/5729825
本文介绍Hibernate环境下多对多关系的删除操作，包括通过主控方和被控方删除中间表记录的不同方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

只删除中间表，可以通过以下代码。

/**
* 多对多 通过主控方删除中间表(其余记录都不变)
*/
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多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立

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

 

Pojo

Java代码 复制代码
  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. }  
/**
 * Course Entity
 * see table: tbl_course
 */
package com.leo.domain;

import java.util.HashSet;
import java.util.Set;

/**
 * @author superleo
 * 
 */
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代码 复制代码
  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. }  
/**
 * Teacher Entity
 * see table: tbl_teacher
 */
package com.leo.domain;

import java.util.HashSet;
import java.util.Set;

/**
 * @author superleo
 * 
 */
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代码 复制代码
  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>  

 

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

 

Java代码 复制代码
  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.     }  
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代码 复制代码
    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.     }  
    /**
	 * 多对多 主控方删除(可以删除中间表记录)
	 */
	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代码 复制代码
    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. }  
    	/**
	 * 多对多 被控方删除(无法删除中间表记录)
	 */
	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代码 复制代码
    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. }  
    	/**
	 * 多对多 被控方删除(可以删除中间表记录)
	 */
	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)
    );

wyfh2010
关注
Hibernate通过many-to-one元素的一对一映射
unber的博客
07-01 1059
在这里，我们将通过多对一的many-to-one元素进行一对一的映射。在这种情况下，在主表中创建外键。在这个例子中，一个员工只能有一个地址，一个地址只能属于一个员工。在这里使用双向关联。我们来看看持久化类。
hibernate many-to-many级联保存，级联更新，级联删除
05-13
在Java的持久化框架Hibernate中，Many-to-Many关系是一种常见的数据库表之间的关联方式，它表示一个实体可以与多个其他实体进行关联，反之亦然。本文将深入探讨如何在Hibernate中处理Many-to-Many关系的级联保存、...
Hibernate多对多删除问题的解决
sukyle的专栏
10-22 593
Hibernate多对多删除问题的解决 http://www.javaeye.com/topic/154587?page=1  Hibernate多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立老师Teacher 与 课程Course 是一个多对多的关系，Pojo与XMl配置如下。 
sqlalchemy中一对多、多对多关系中，数据的添加与删除(append/remove)
weixin_38644677的博客
03-10 5671
在设置了以后数据库自动提交（app.config[“SQLALCHEMY_COMMIT_ON_TEARDOWN”] = True），可以直接使用remove、append方法，因为使用属性关系后，生成的对象可以向列表一样操作。此外使用remove和append方法删除生成的仅仅是外键，并未真实删除数据。 一对多、多对多表的关联： 在sqlalchemy中使用relationship关系属性来关联相...
Hibernate多对多级联删除的问题
Julyraining的博客
10-11 3092
当数据库两个表是多对多关联关系的时候，维护者应该是数据量较少的一方。 即维护者inverse=false，被维护者inverse = true。 级联关系建议都是cascade= save-update。 下面代码中，Project负责维护Employee的更新。 删除维护者的时候可以直接delete。 Transaction tx
MySQL多对多表关系删除策略
ren814的博客
08-16 3219
菜单表： CREATE TABLE `es_menu` (   `id` bigint(20) NOT NULL auto_increment,   `menuname` varchar(24) NOT NULL,   `sort` tinyint(4) NOT NULL,   `inputtime` datetime NOT NULL,   PRIMARY KEY  (`id`) ) ENGI...
使用注解的Hibernate many-to-many映射
maoyeqiu的专栏
12-25 6136
many to many映射是在两个实体间，一个实体可以和其他的多个实体建立关系。例如一个捐赠服务的实体Subscription实体和读取实体都是两个实体，一个捐赠可以有多个读者，一个读者可以有多个捐赠，在这篇文中我们将会学习在Hibernate3中怎么建立这种关系。 提出解决方案 为了演示多对多的关系，我们连接两个实体Reader实体和Subscription实体。他们的实体关系如下：
hibernate many-to-one/one-to-many
wyplj2015的博客
03-24 368
今天看一个hibernate的代码，把自己整晕了 1、many-to-one 先看一个例子，多对一实例（Employee-Department）： Department实体类： public class Department { private int id; private String name; //setter和ge...
Hibernate Many-to-Many
永无止境
01-27 821
Hibernate 多对多注解
Hibernate实现many-to-many的映射关系
08-26
在本文中，我们将深入探讨如何使用Hibernate来实现多对多（many-to-many）的映射关系。 首先，多对多映射关系通常涉及到两个实体类之间的关联，例如在学生选课的例子中，学生（Student）和课程（Course）之间存在多...
Hibernate one-to-many / many-to-one关系映射
07-03
"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型，用于表示实体间的关联。在这个主题中，我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一（one-to-one）与一对多（one-to-...
Hibernate many-to-many
05-11
"Hibernate many-to-many"指的是Hibernate中处理多对多关联关系的一种方式。多对多关系是两个实体类之间存在的一种复杂关联，比如学生和课程之间的关系，一个学生可以选修多门课程，一门课程也可以被多个学生选修。 ...
应急响应处置案例(上)
Neolock的博客
07-28 1077
Web安全事件应急响应案例
哈工大威海集合论与图论课件.zip
08-23
哈工大威海集合论与图论课件
基于扰动观察法的光伏MPPTBoost变换器最大功率点跟踪技术研究
08-23
光伏最大功率点跟踪（MPPT）技术及其在光伏发电系统中的重要性。重点讨论了基于扰动观察法（P&O）的MPPT技术和MPPT Boost变换器的应用。扰动观察法通过周期性改变光伏阵列的工作电压或电流并观察输出功率变化，进而调整工作点，确保光伏阵列始终处于最大功率点附近。而MPPT Boost变换器则通过高效的电压或电流控制，进一步提高了系统的输出效率。两者结合使用，在光强和温度等环境条件变化时，能够显著提升光伏系统的发电效率和寿命。 适用人群：从事光伏系统设计、安装和维护的专业技术人员，以及对清洁能源技术感兴趣的科研人员。 使用场景及目标：适用于需要优化光伏系统性能的场合，如太阳能电站、分布式光伏发电系统等。目标是提高光伏系统的发电效率，降低能耗，延长设备使用寿命。 其他说明：本文不仅提供了理论依据和技术细节，还强调了清洁能源发展的重要性和未来的研究方向。
哈工大威海近世代数课件.zip
最新发布
08-23
哈工大威海近世代数课件
Hibernate many-to-many映射与并发处理详解
在使用Hibernate处理数据库关系映射时，尤其是涉及到多对多（many-to-many）关系时，了解其并发控制机制是非常重要的。以下是对标题“(5)Hibernate中的many-to-many和并发”所涉及的知识点进行的详细说明。 ### 多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值