2. 程式人生 > 實用技巧 >hibernate多對多（many-to-many）

hibernate多對多（many-to-many）

阿新 • • 發佈：2020-10-29

hibernate多對多（many-to-many）：在操作和效能方面都不太理想，所以多對多的對映使用較少，實際使用中最好轉換成一對多的物件模型；hibernate會為我們建立中間關聯表，轉換成兩個一對多。

1. E-R圖


2. 實體類：

Teacher實體類如下：

Java程式碼
  1. packagecom.reiyen.hibernate.domain;
  3. importjava.util.Set;
  5. publicclassTeacher{
  7. privateintid;
  8. privateStringname;
  9. privateSet<Student>students;
  10. //setter和getter方法
  12. }
package com.reiyen.hibernate.domain;

import java.util.Set;

public class Teacher {

	private int id;
	private String name;
	private Set<Student> students;
       //setter和getter方法

}

Student實體類如下：

Java程式碼
  1. packagecom.reiyen.hibernate.domain;
  3. importjava.util.Set;
  5. publicclassStudent{
  7. privateintid;
  8. privateStringname;
  9. privateSet<Teacher>teachers;
  10. //setter和getter方法
  12. }
package com.reiyen.hibernate.domain;

import java.util.Set;

public class Student {

	private int id;
	private String name;
	private Set<Teacher> teachers;
        //setter和getter方法

}

3.對映檔案如下：

Teacher.hbm.xml如下：

Xml程式碼
  1. <?xmlversion="1.0"?>
  2. <!DOCTYPEhibernate-mappingPUBLIC
  3. "-//Hibernate/HibernateMappingDTD3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mappingpackage="com.reiyen.hibernate.domain">
  6. <classname="Teacher">
  7. <idname="id">
  8. <generatorclass="native"/>
  9. </id>
  10. <propertyname="name"/>
  11. <!--通過table項告訴hibernate中間表的名稱-->
  12. <setname="students"table="teacher_student">
  13. <!--通過key屬性告訴hibernate在中間表裡面查詢teacher_id值相應的teacher記錄-->
  14. <keycolumn="teacher_id"/>
  15. <!--通過column項告訴hibernate對student表中查詢student_id值相就的studnet記錄-->
  16. <many-to-manyclass="Student"column="student_id"/>
  17. </set>
  18. </class>
  19. </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 package="com.reiyen.hibernate.domain">
	<class name="Teacher">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<!-- 通過table項告訴hibernate中間表的名稱 -->
		<set name="students" table="teacher_student">
			<!-- 通過key屬性告訴hibernate在中間表裡面查詢teacher_id值相應的teacher記錄 -->
			<key column="teacher_id" />
			<!-- 通過column項告訴hibernate對student表中查詢student_id值相就的studnet記錄 -->
			<many-to-many class="Student" column="student_id" />
		</set>
	</class>
</hibernate-mapping>

Student.hbm.xml如下：

Xml程式碼
  1. <?xmlversion="1.0"?>
  2. <!DOCTYPEhibernate-mappingPUBLIC
  3. "-//Hibernate/HibernateMappingDTD3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mappingpackage="com.reiyen.hibernate.domain">
  6. <classname="Student">
  7. <idname="id">
  8. <generatorclass="native"/>
  9. </id>
  10. <propertyname="name"/>
  11. <setname="teachers"table="teacher_student">
  12. <keycolumn="student_id"/>
  13. <many-to-manyclass="Teacher"column="teacher_id"/>
  14. </set>
  15. </class>
  16. </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 package="com.reiyen.hibernate.domain">
	<class name="Student" >
		<id name="id" >
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="teachers" table="teacher_student">
		<key column="student_id" />
		<many-to-many class="Teacher" column="teacher_id"/>
		</set>
	</class>
</hibernate-mapping>

一定要注意對映檔案中<many-to-many class="Teacher" column="teacher_id"/>中class的值，它必須與你另一個關聯對映檔案中的class屬性的name值一致，其實就是與你的實體類的類名一致,如：<many-to-many class="Teacher" column="teacher_id"/>中class的值就不能寫成"teacher"。如果寫成這樣的話，就會丟擲如下異常：An association from the table teacher_student refers to an unmapped class: com.reiyen .hibernate.domain.teacher

4. 測試程式如下：

Java程式碼
  1. publicclassMany2Many{
  2. publicstaticvoidmain(String[]args){
  3. add();
  4. //query(1);
  5. }
  7. staticvoidquery(intid){
  8. Sessions=null;
  9. Transactiontx=null;
  10. try{
  11. s=HibernateUtil.getSession();
  12. tx=s.beginTransaction();
  13. Teachert=(Teacher)s.get(Teacher.class,id);
  14. System.out.println("students:"+t.getStudents().size());
  15. tx.commit();
  16. }finally{
  17. if(s!=null)
  18. s.close();
  19. }
  20. }
  22. staticvoidadd(){
  23. Sessions=null;
  24. Transactiontx=null;
  25. try{
  26. Set<Teacher>ts=newHashSet<Teacher>();
  28. Teachert1=newTeacher();
  29. t1.setName("t1name");
  30. ts.add(t1);
  32. Teachert2=newTeacher();
  33. t2.setName("t2name");
  34. ts.add(t2);
  36. Set<Student>ss=newHashSet<Student>();
  37. Students1=newStudent();
  38. s1.setName("s1");
  39. ss.add(s1);
  41. Students2=newStudent();
  42. s2.setName("s2");
  43. ss.add(s2);
  45. t1.setStudents(ss);//1
  46. t2.setStudents(ss);//1
  47. //
  48. //s1.setTeachers(ts);//2
  49. //s2.setTeachers(ts);//2
  51. s=HibernateUtil.getSession();
  52. tx=s.beginTransaction();
  53. s.save(t1);
  54. s.save(t2);
  55. s.save(s1);
  56. s.save(s2);
  57. tx.commit();
  58. }finally{
  59. if(s!=null)
  60. s.close();
  61. }
  62. }
  63. }
public class Many2Many {
	public static void main(String[] args) {
		add();
		//query(1);
	}

	static void query(int id) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			Teacher t = (Teacher) s.get(Teacher.class, id);
			System.out.println("students:" + t.getStudents().size());
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}

	static void add() {
		Session s = null;
		Transaction tx = null;
		try {
			Set<Teacher> ts = new HashSet<Teacher>();

			Teacher t1 = new Teacher();
			t1.setName("t1 name");
			ts.add(t1);

			Teacher t2 = new Teacher();
			t2.setName("t2 name");
			ts.add(t2);

			Set<Student> ss = new HashSet<Student>();
			Student s1 = new Student();
			s1.setName("s1");
			ss.add(s1);

			Student s2 = new Student();
			s2.setName("s2");
			ss.add(s2);

			t1.setStudents(ss);  //1
			t2.setStudents(ss);  //1
//			
//			s1.setTeachers(ts);  //2
//			s2.setTeachers(ts);  //2

			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(t1);
			s.save(t2);
			s.save(s1);
			s.save(s2);
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}
}

執行此程式後：控制檯列印的sql語句如下所示：

Hibernate: insert into Teacher (name) values (?)
Hibernate: insert into Teacher (name) values (?)
Hibernate: insert into Student (name) values (?)
Hibernate: insert into Student (name) values (?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)

一共在中間表裡面插入了4條記錄。

中間表結構如下所示：

DROP TABLE IF EXISTS `test`.`teacher_student`;
CREATE TABLE `test`.`teacher_student` (
`teacher_id` int(11) NOT NULL,
`student_id` int(11) NOT NULL,
PRIMARY KEY (`student_id`,`teacher_id`),
KEY `FK2E2EF2DE6C8A2663` (`teacher_id`),
KEY `FK2E2EF2DE5BEEDBC3` (`student_id`),
CONSTRAINT `FK2E2EF2DE5BEEDBC3` FOREIGN KEY (`student_id`) REFERENCES `student` (`id`),
CONSTRAINT `FK2E2EF2DE6C8A2663` FOREIGN KEY (`teacher_id`) REFERENCES `teacher` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

表中插入的記錄如下所示：

mysql> select * from teacher_student;
+------------+------------+
| teacher_id | student_id |
+------------+------------+
| 1 | 1 |
| 1 | 2 |
| 2 | 1 |
| 2 | 2 |
+------------+------------+
4 rows in set (0.00 sec)

程式中註釋為1的語句非常重要，它是建立Teacher與Student關聯的語句，如果沒有這兩條語句，雖然程式照樣會執行，但是在中間表teacher_student沒有任何記錄，也就是Teacher與Student之間未關聯。

當然你也可以通過程式中註釋為2的語句來建立Teacher與Student之間的關聯關係，同樣會產生與註釋為1的語句的效果。但是你不能在程式中同時出現以上四句程式，否則會丟擲異常（ PRIMARY KEY (`student_id`,`teacher_id`),所以會出現主鍵衝突的異常）,：

Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (teacher_id, student_id) values (?, ?)
Hibernate: insert into teacher_student (student_id, teacher_id) values (?, ?)
Hibernate: insert into teacher_student (student_id, teacher_id) values (?, ?)
Hibernate: insert into teacher_student (student_id, teacher_id) values (?, ?)
Hibernate: insert into teacher_student (student_id, teacher_id) values (?, ?)
Exception in thread "main" org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

解決上面產生異常的辦法是設定inverse屬性。即在Tearcher一端或Student一端設定inverse="true"，即讓他們之中的某一方放棄維護關聯關係。此時，雖然上面四句程式在測試程式中同時出現了（其實就是在物件模型上相互設定了他們的關聯關係），但程式照樣能執行正常，因為了在資料庫模型上，只會有兩句程式生效，也就是沒有設定inverse="true"的那一端會去維護關聯關係。有關inverse的說細資訊，可以參看我的文章hibernate級聯（cascade和inverse）.

執行測試程式中的查詢測試，控制檯列印的資訊如下所示：

Hibernate: select teacher0_.id as id5_0_, teacher0_.name as name5_0_ from Teacher teacher0_ where teacher0_.id=?
Hibernate: select students0_.teacher_id as teacher1_1_, students0_.student_id as student2_1_, student1_.id as id7_0_, student1_.name as name7_0_ from teacher_student students0_ left outer join Student student1_ on students0_.student_id=student1_.id where students0_.teacher_id=?
students:2

從打印出的sql語句可以看出，多對多關係進行查詢時，效率是比較低的。

本文來自轉載

相關推薦

hibernate多對多（many-to-many）

hibernate多對多（many-to-many）：在操作和效能方面都不太理想，所以多對多的對映使用較少，實際使用中最好轉換成一對多的物件模型；hibernate會為我們建立中間關聯表，轉換成兩個一對多。

詳解sql中的參照完整性（一對一，一對多，多對多）

一、參照完整性 參照完整性指的就是多表之間的設計,主要使用外來鍵約束。 多表設計: 一對多、多對多、一對一設計

Python學習第135天（Django的ORM多對多查詢）

今天總結一下，感覺近期的知識點比較多，但是很多測試是為了測試而測試，不具備實際的使用價值，所以打算開始加快學習進度，粗略聽，簡單總結，在案例實踐的時候進行重點了解，今天主要看的是ORM的多對多查詢。

httprunner 3.x--引數化parameters（引數和值一對多，多對多等）

上一篇裡寫的httprunner 3.x--variables變數和宣告(變數和值一一對應)中的variables是對 “一對一”的引數有用，

Hibernate註解(一對一、一對多、多對多)

Hibernate一對多關係操作 1、建立兩個實體類。 　　　　一個實體類是商品類，另一個實體類是商品的分類類。

Python學習第151天（Django之多對多）

應用場景 在某表中建立一行資料時，有一個可以多選的下拉框（一對一是單選框）例如：建立使用者資訊，需要為使用者指定多個愛好

JPA(Java Persistence API)學習十二（多對多對映）

1.概述 多對多對映表示集合值關聯，其中任何數量的實體可以與其他實體的集合關聯。

Mybatis（一對一、一對多、多對多）操作

* 首先列出示例中用到的資料庫表 user表： accout表： role表： user_role表： 建表語句如下：

Hibernate雙向多對多對映關係配置程式碼例項

1、實體類 package com.yl.bean; import java.io.Serializable; import java.util.Set; /** * 商品實體類

【MyBatis】多對多條件下插入中間表（使用insert標籤的屬性）

此文轉載自：https://blog.csdn.net/weixin_44757863/article/details/110010556 文章目錄 需求解決方案測試編寫Dao層Service層Test類

Hibernate編寫多對多單向關係的CRUD操作

技術標籤：框架hibernate Hibernate編寫多對多單向關係的CRUD操作 一.專案架構 二.實現功能

MySQL多對多建立表語句（防忘記）

技術標籤：mybatisMySQL語句mysql -- 演員表 CREATE TABLE actor (id INTEGER NOT NULL -- 演員編號

Hibernate 多對多關係

技術標籤：JavaHibernatehibernatemysqljava Hibernate 多對多關係 環境 java 12.0.1 Apache Maven 3.6.3

MySQL：多表關係設計（一對多 / 多對多 / 一對一）

<0> 多表關係概述 　　實際開發中，一個專案通常需要很多張表才能完成。

Spring Boot 入門系列（二十八） JPA 的實體對映關係，一對一，一對多，多對多關係對映！

前面講了Spring Boot 使用 JPA，實現JPA的增、刪、改、查的功能，同時也介紹了JPA的一些查詢，自定義SQL查詢等使用。JPA使用非常簡單，功能非常強大的ORM框架，無需任何資料訪問層和sql語句即可實現完整的資料操作方

10Django資料表關聯關係對映（一對一、一對多、多對多）

1. 一對多關係型別 這種型別在資料庫中體現是外來鍵關聯關係，它在和其他的 Model 建立關聯同時也和自己建立關聯，用來描述一對多的關係，例如一個作者可以寫很多不同的書，但是這些書又只能對應這一個作者，再比如

Spring data 資料庫建表（一對一，一對多，多對多）

本文節選擇電子書《Netkiller Java 手札》 DBA 如果你在不學習程式設計，你將失業。如今我們對DBA的依賴越來越少，多數框架都支援實體關係對映，通過面向物件程式設計即可定義資料庫結構。資料庫設計也是在這個階段完

django 多對多表的建立和插入程式碼實現

這篇文章主要介紹了django-多對多表的建立和插入程式碼實現,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Django 多對多欄位的更新和插入資料例項

表的普通欄位 一對多欄位 多對多欄位 插入資料 #插入資料 def add(request): G_title=request.POST.get(\'title\')#-------值為：python書本

Django Xadmin多對多欄位過濾例項

在xadmin中是不能像原生admin那樣使用formfield_for_manytomany方法來過濾多對多欄位