Hibernate多对多增加与修改(精华)

最新推荐文章于 2018-12-29 08:56:26 发布
原创 最新推荐文章于 2018-12-29 08:56:26 发布 · 104 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了Hibernate中多对多关系的管理方法，包括如何建立关系、删除关系及不同场景下的注意事项。提供了详细的代码示例，展示了如何通过主控方和被控方进行操作。

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 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代码
  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>  
<?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代码
  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. 初步断定可能与事务有关，如果有人遇到了，并知道为什么，希望能留言，先谢谢大家了。

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

/**
* 多对多 通过主控方删除中间表(其余记录都不变)
*/
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();
}

注：三个表的表结构

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)
    );


Hibernate基础：快速入门(5)：删除数据
知行合一 止于至善
12-12 6292
数据库的操作增删改查，或者CRUD是最常见的操作。这篇文章中介绍删除数据的方法
Hibernate系列教材 （五）- 基础 - 删除一条数据
MAGIC_LAN的博客
04-05 316
推荐使用diffmerge软件，进行文件夹比较。把你自己做的项目文件夹，和我的可运行项目文件夹进行比较。在确保可运行项目能够正确无误地运行之后，再严格照着教程的步骤，对代码模仿一遍。的可运行项目，配置运行起来，确认可用之后，再学习做了哪些步骤以达到这样的效果。这个软件很牛逼的，可以知道文件夹里哪两个文件不对，并且很明显地标记出来。模仿过程难免代码有出入，导致无法得到期望的运行结果，此时此刻通过比较。( 可运行项目 ) 和自己的代码，来定位问题所在。，可以较为明显地提升学习速度，跨过学习路上的各个槛。
hibernate批量删除
02-25
在我们的Java项目中，批量更新是指在一个事务中更新大批量数据，批量删除是指在一个事务中删除大批量数据。批量删除虽然在Hibernate里也可以实现，但因Hibernate的实现机制是一个一个删除，在数量大的情况下很影响效率；其实Hibernate提供的JDBC接口，可以方便的进行批量的更新和删除。
Hibernate多对多删除问题的解决
Java专栏
01-09 270
Hibernate多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立老师Teacher 与 课程Course 是一个多对多的关系，Pojo与XMl配置如下。 Pojo/** * Course Entity * see table: tbl_course */ package com.leo.domain; im...
Hibernate：多对多删除
qq_40973475的博客
10-28 930
案例： 书籍类（Book.java）和书籍类别（Category.java） 表结构： t_hibernate_book表： t_hibernate_category表： t_hibernate_book_category表(中间表)： 先创建多对多联系： book类： package com.crud.five.entity; import java.util.H...
Hibernate检索策略与面试精华
在面试中，关于Hibernate的讨论通常涵盖其核心概念、检索策略、SQL日志记录、缓存策略以及与其他框架的整合等方面。以下是对这些知识点的详细解释： 1. Hibernate检索策略： - 立即检索：当对象被访问时，所有关联...
Hibernate面试精华知识点---------不看你会后悔
热门推荐
Cs_hnu_scw的博客
01-04 2万+
这篇文章主要是对Hibernate中的一些知识点重点描述一下，因为这是在很多面试的时候都会问到的，而且还用用Hibernate与Mybatis进行比较，所以，对Hibernate其中的一些内容和原理都是需要进行了解的了。 1：进行更新操作的时候，为什么一般都是需要先获取到数据库中原数据，然后再把新对象的内容进行复制，然后再执行更新操作呢？比如下面的代码(1)而不是直接代码(2) 其中Persi
J2EE面试精华： Hibernate 优缺点及Oracle相关技术探讨
在J2EE英文面试中，面试官可能会考察候选人对Struts、Spring、Hibernate、Oracle以及Agile开发方法的理解。以下是关于Hibernate框架的优缺点，这通常会在技术面试中作为讨论点： **优点（Advantages）：** 1. **...
j2EE项目设计文档精华汇总：涵盖多个管理系统
题库设计要支持不同题型，如选择题、填空题、简答题等，并能灵活地进行试题的增加、删除、修改和查询。 #### 5.2 考试管理 包括考试设置、考试监控、自动评分和成绩统计等功能，实现线上考试的全过程管理。 #### ...
SSH框架精华学习笔记整理
2. **面向切面编程AOP**：允许在不修改源代码的情况下增加额外的功能，如日志、事务管理等。 3. **事务管理**：Spring提供了声明式事务管理，使事务的控制更为灵活和强大。 4. **Spring MVC**：Spring提供的MVC框架...
ssm多对多整合 学生选课 多对多增删改查
12-08
本项目是多对多的项目，在前台使用了jquery，用ajax来进行回显更新，前后台用json进行传值，并且写了模糊和分页。在此声明一下，里面的模糊和分页和一对多的模糊分页是不一样的，大家下载需要认真看一下，这个项目写的逻辑比较清晰，采用逆向工程生成了部分代码，并且配置了懒加载。逻辑清晰，没有bug。压缩包中并且附带了sql文件，可以直接运行跑通，如果有任何问题，欢迎联系本人进行交流探讨。
关于Hibernate的多对多的删除
qq_41460161的博客
12-29 317
如果只是想删除两个表之间建立的关系，则只需要在持久层做如下操作：         Session session = HibernateUtils.getCurrentSession();         String hql="from Supplier s where s.s_name=:name";         @SuppressWarnings("rawtypes")        ...
多对多的删除
赵艳芳
12-24 224
在hibernate中我有两个表user和book这两个表同时建立了多对多的关系,并有一个中间表user_book; 我要删除book表应该怎么删啊;现在一删除就报错;
hibernate 删除
teclogid的专栏
11-28 566
 hibernate删除时，如果一个对象的某个属性是nullable = false,只传给这个对象id是不够的，无法通过数据合法性检查。可以随便给它赋个值，也可以把nullable = false去掉。当然，还可以在删除之前先做查询。
Hibernate 多对多 删除操作
上班搞IT，下班搞ITF。
06-17 1398
Hibernate 多对多 删除操作(many-to-many)Hibernate多对多的例子不少，但仔细一看，大多数都是保存的，删除谈的少，但问题还不少，因此有必须简单测试一下，以下我们来个简单的多对多关系建立老师Teacher 与 课程Course 是一个多对多的关系，Pojo与XMl配置如下。Pojo/** * Course Entity * see table: t
hibernate的多对多的关联 2（增加、删除）
cao_2000的博客
10-27 810
重点： 1、级联新增 inverse属性值的设置 2、 级联删除 重点解析： 1.hibernate的多对多 1.1 hibernate可以直接映射多对多关联关系(看作两个一对多) 讲解inverse； 总共四种 (false 是控制方 ，true 是被控制方)，其中有两种正确，两种错误 * 1、book：false category:true ✓（代表意思是：将维护的责任交给b...
Hibernate删除操作
Arthur0088的专栏
09-25 728
import org.hibernate.Query; import tt.TUser; import tt.TUserDAO; public class Delete { public static void main(String[] args)//主方法,用于运行二个删除操作的方法 { //Delete.deleteOne(13); //Delete.del...
hibernate删除数据
青苔小榭
07-09 5583
我这里用到的是把一张表里的数据都删除 //创建一个事务 //根据hibernate配置文件的配置信息，创建一个configuration实例 Configuration configuration = new Configuration().configure(); //创建SessionFactory实例 SessionFact...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值