Hibernate 的一對多關聯映射

之前在學習 Hibernate 的時候，其實都是單表的操作。在實際的開發當中，比如做一個商城，就需要好多張數據庫表，表與表之間是有關系的。之前些做一些關聯查詢或者是一些基本的查詢操作的時候，都是寫 SQL 語句去關聯兩張表，這樣子稍微有一點麻煩。那么有了 Hibernate? 之后，它就可以解決這類問題了。在這之前，先了解一些數據庫 表之間的關系，它是有三種關系的。

1、數據庫表與表之間的關系?

也就是說我們的一個系統，抽取出來的那些實體，因為表是根據實體來的 ，那么它會根據實體分成 這三類的關系。也就是說你所有的系統里邊，所有抽取出來的實體，也只有這三種關系。

① 一對多的關系

　　什么關系屬于一對多？

　　　　一個部門對于多個員工，一個員工只能屬于一個部門。

　　　　一個客戶可以對應多個聯系人，一個聯系人只能屬于某一個客戶（個人認為是錯誤的）。

　　一對多的創表原則

② 多對多的關系

　　什么樣的關系屬于多對多？

　　　　一個學生可以選擇多門課程，一門課程也可以被多個學生選擇。

　　　　一個用戶可以選擇多個角色，一個角色也可以被多個用戶選擇。

　　多對多建表原則

③ 一對一的關系（了解，實際開發過程中應用很少）

　　在實際開發過程中，一對一的關系可以建成一張表，除非 是有特殊的需求需要將表分開。

　　唯一外鍵對應

　　　　在一張表添加外鍵字段，并作唯一約束。

　　主鍵對應

　　　　需要將兩張表關聯。

?一對多怎么表示？一個客戶應該有多個聯系人，一個聯系人只能屬于一個客戶。

　　現在要通過 ORM 的方式表示：一個聯系人只能屬于某一個客戶。開發語言是面向對象的 ，怎么表示一個聯系人屬于一個客戶呢？放置一個客戶的對象，所有以后創表的時候會創建外鍵，但是創建實體的時候要放的是“一”的一方的一個對象。所以以后碰到外鍵的時候不要寫外鍵的名稱了，把外鍵改成“一”的一個對象，并生成相應的get & set。

　　還是通過 ORM 的方式表示 ：一個客戶對應多個聯系人。放置的是“多”的一方的集合。需要注意的是，hibernate 默認使用的是 set 集合，不是 list 集合。當然，它里面也可以配置 list/map，list 集合應為在 hibernate 中需要對 list 數據進行有序排列。如果配置 list 集合，hibernate 需要在數據庫表中多建一列，這一列就是用于 hibernate 排序的，它會用0、1、2、3、4、5...列這個順序，那么表會多出來一列。所以一般是使用的都是 set 集合。

　　現在做的是雙向關聯，就是從客戶這邊查聯系人可以查，從聯系人這邊查客戶也可以查。如果只做了單向關聯，只在聯系人那邊放客戶對象了，客戶這邊沒有放聯系人的集合，那你在查詢的時候，只能從聯系人查到客戶，就不能從客戶查聯系人了。當然，兩邊都做好了，想從那邊去查都沒問題（也可以做出單項的）。

Hibernate 的一對多關聯映射

（一）、Hibernate 的一對多關聯映射

1、創建一個項目，引入相應 jar 包

2、創建數據庫和表

CREATE TABLE `cst_customer` (`cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客戶編號(主鍵)',`cust_name` varchar(32) NOT NULL COMMENT '客戶名稱(公司名稱)',`cust_source` varchar(32) DEFAULT NULL COMMENT '客戶信息來源',`cust_industry` varchar(32) DEFAULT NULL COMMENT '客戶所屬行業',`cust_level` varchar(32) DEFAULT NULL COMMENT '客戶級別',`cust_phone` varchar(64) DEFAULT NULL COMMENT '固定電話',`cust_mobile` varchar(16) DEFAULT NULL COMMENT '移動電話',PRIMARY KEY (`cust_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;CREATE TABLE `cst_linkman` (`lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '聯系人編號(主鍵)',`lkm_name` varchar(16) DEFAULT NULL COMMENT '聯系人姓名',`lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客戶id',`lkm_gender` char(1) DEFAULT NULL COMMENT '聯系人性別',`lkm_phone` varchar(16) DEFAULT NULL COMMENT '聯系人辦公電話',`lkm_mobile` varchar(16) DEFAULT NULL COMMENT '聯系人手機',`lkm_email` varchar(64) DEFAULT NULL COMMENT '聯系人郵箱',`lkm_qq` varchar(16) DEFAULT NULL COMMENT '聯系人qq',`lkm_position` varchar(16) DEFAULT NULL COMMENT '聯系人職位',`lkm_memo` varchar(512) DEFAULT NULL COMMENT '聯系人備注',PRIMARY KEY (`lkm_id`),KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

　　在 MySQL 數據庫中，將兩張表拖拽到“架構設計器”選項卡就可以看到兩張表之間的關系。

3、創建實體

① “一”的一方的實體

② “多的一方的實體”

4、創建映射文件

① 多的一方的映射的創建（聯系人表的 hibernate 配置文件? ?LinkMan.hbm.xml）

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping><class name="com.itheima.hibernate.domain.LinkMan" table="cst_linkman"><!-- 建立OID與主鍵映射 --><id name="lkm_id" column="lkm_id"><generator class="native"/></id><!-- 建立普通屬性與表字段映射 --><property name="lkm_name"/><property name="lkm_gender"/><property name="lkm_phone"/><property name="lkm_mobile"/><property name="lkm_email"/><property name="lkm_qq"/><property name="lkm_position"/><property name="lkm_memo"/><!-- 配置多對一的關系：放置的是一的一方的對象 --><!-- many-to-one標簽* name :一的一方的對象的屬性名稱。* class :一的一方的類的全路徑。* column :在多的一方的表的外鍵的名稱。
　　　　　　　操作 column 就相當與操作數據庫中表的外鍵--><many-to-one name="customer" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/></class> </hibernate-mapping>

② “一”的一方的映射的創建（客戶表的 hibernate 配置文件? ?Customer.hbm.xml）

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping><class name="com.itheima.hibernate.domain.Customer" table="cst_customer"><!-- 建立OID與主鍵映射 --><id name="cust_id" column="cust_id"><generator class="native"/></id><!-- 建立普通屬性與數據庫表字段映射 --><property name="cust_name" column="cust_name" /><property name="cust_source" column="cust_source"/><property name="cust_industry" column="cust_industry"/><property name="cust_level" column="cust_level"/><property name="cust_phone" column="cust_phone"/><property name="cust_mobile" column="cust_mobile"/><!-- 配置一對多的映射：放置的多的一方的集合 --><!-- set標簽 ：* name ：多的一方的對象集合的屬性名稱。* cascade：級聯* inverse：放棄外鍵維護權。--><set name="linkMans"><!--key標簽* column：多的一方的外鍵的名稱。--><key column="lkm_cust_id"/><!-- one-to-many標簽* class :多的一方的類的全路徑--><one-to-many class="com.itheima.hibernate.domain.LinkMan"/></set></class> </hibernate-mapping>

5、創建核心配置文件（hibernate.cfg.xml）

　　將要連接的數據庫名稱改一下，還有要引入的映射文件，這里要引入兩個映射文件。

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration><session-factory><!-- 連接數據庫的基本參數 --><property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><property name="hibernate.connection.url">jdbc:mysql:///hibernate_day03</property><property name="hibernate.connection.username">root</property><property name="hibernate.connection.password">abc</property><!-- 配置Hibernate的方言 --><property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property><!-- 可選配置================ --><!-- 打印SQL --><property name="hibernate.show_sql">true</property><!-- 格式化SQL --><property name="hibernate.format_sql">true</property><!-- 自動創建表 --><property name="hibernate.hbm2ddl.auto">update</property><!-- 配置C3P0連接池 --><property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property><!--在連接池中可用的數據庫連接的最少數目 --><property name="c3p0.min_size">5</property><!--在連接池中所有數據庫連接的最大數目 --><property name="c3p0.max_size">20</property><!--設定數據庫連接的過期時間,以秒為單位,如果連接池中的某個數據庫連接處于空閑狀態的時間超過了timeout時間,就會從連接池中清除 --><property name="c3p0.timeout">120</property><!--每3000秒檢查所有連接池中的空閑連接 以秒為單位--><property name="c3p0.idle_test_period">3000</property><!-- 設置事務隔離級別 --><property name="hibernate.connection.isolation">4</property><!-- 配置當前線程綁定的Session --><property name="hibernate.current_session_context_class">thread</property><!-- 引入映射 --><!-- <mapping resource="com/itheima/hibernate/domain/Customer.hbm.xml"/><mapping resource="com/itheima/hibernate/domain/LinkMan.hbm.xml"/> --><mapping resource="com/itheima/hibernate/domain/User.hbm.xml"/><mapping resource="com/itheima/hibernate/domain/Role.hbm.xml"/></session-factory> </hibernate-configuration>

?

?

7、創建測試類

package com.itheima.hibernate.demo1;import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test;import com.itheima.hibernate.domain.Customer; import com.itheima.hibernate.domain.LinkMan; import com.itheima.hibernate.utils.HibernateUtils;/*** 一對多的測試類* @author jt**/ public class HibernateDemo1 {@Test// 保存2個客戶 和 3個聯系人 并且建立好關系public void demo1(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建兩個客戶Customer customer1 = new Customer();customer1.setCust_name("王東");Customer customer2 = new Customer();customer2.setCust_name("趙洪");// 創建三個聯系人LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("鳳姐");LinkMan linkMan2 = new LinkMan();linkMan2.setLkm_name("如花");LinkMan linkMan3 = new LinkMan();linkMan3.setLkm_name("旺財");// 設置關系: linkMan1.setCustomer(customer1);linkMan2.setCustomer(customer1);linkMan3.setCustomer(customer2);customer1.getLinkMans().add(linkMan1);customer1.getLinkMans().add(linkMan2);customer2.getLinkMans().add(linkMan3);// 保存數據: session.save(linkMan1);session.save(linkMan2);session.save(linkMan3);session.save(customer1);session.save(customer2);tx.commit();} @Test/*** 區分cascade和inverse的區別*/public void demo9(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("李兵");LinkMan linkMan = new LinkMan();linkMan.setLkm_name("鳳姐");customer.getLinkMans().add(linkMan);// 條件在Customer.hbm.xml上的set中配置了cascade="save-update" inverse="true"session.save(customer); // 客戶會插入到數據庫，聯系人也會插入到數據庫，但是外鍵為null tx.commit();} }

（二）、Hibernate 的一對多相關操作

1、一對多關系只保存一邊是否可行?

將數據做了雙向關連以后，是否可以 只保存一邊的 數據呢？不可以，回報一個瞬時對象異常的錯誤。什么是瞬時對象異常啊，就是說持久態的對象關聯了一個瞬時態的對象。客戶對象本來是瞬時態的對象 ，一保存就變成持久態的對象了，之前和聯系人對象做了關聯，但聯系人對象 還是瞬時態的對象，所以會報錯。

　　 @Test// 一對多關系只保存一邊是否可以public void demo2(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("趙洪");LinkMan linkMan = new LinkMan();linkMan.setLkm_name("如花");customer.getLinkMans().add(linkMan);linkMan.setCustomer(customer);// 只保存一邊是否可以：不可以，報一個瞬時對象異常：持久態對象關聯了一個瞬時態對象。// session.save(customer); session.save(linkMan);tx.commit();}

2、一對多的級聯操作

　　如果想只保存一邊，那么要通過一個配置，叫做級聯操作。

　　級聯操作包含有常用的兩種級聯操作，一種叫級聯保存或更新，一種叫級聯刪除。

　　　　什么叫做級聯

　　　　　　級聯指的是，操作一個對象的時候，是否會同時操作其關聯的對象。

　　?　　級聯是有方向性

　　　　　　操作一的一方的時候，是否操作到多的一方

　　　　　　操作多的一方的時候，是否操作到一的一方

　　之前保存一邊是會報異常的，報的是瞬時對象異常。現在要通過配置完成一個級聯操作，要看你操作的主體是什么，我們現在操作的主體是 客戶對象，需要在客戶實體的映射文件中進行配置 。

① 級聯保存或更新

　　保存客戶級聯聯系人（保存“一”的一方，級聯“多”的一方）

　　　　映射文件的配置

<!-- set標簽 ：* name ：多的一方的對象集合的屬性名稱。* cascade：級聯* inverse：放棄外鍵維護權。--><set name="linkMans" cascade="save-update">

　　　　測試類

@Test/*** 級聯保存或更新操作：* * 保存客戶級聯聯系人，操作的主體是客戶對象，需要在Customer.hbm.xml中進行配置* * <set name="linkMans" cascade="save-update">*/public void demo3(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("趙洪");LinkMan linkMan = new LinkMan();linkMan.setLkm_name("如花");customer.getLinkMans().add(linkMan);linkMan.setCustomer(customer);session.save(customer);tx.commit();}

　　保存聯系人級聯客戶（保存“多”的一方，級聯“一”的一方）

　　　　映射文件的配置

　　　　　<!-- many-to-one標簽* name :一的一方的對象的屬性名稱。* class :一的一方的類的全路徑。* column :在多的一方的表的外鍵的名稱。操作 column 就相當與操作數據庫中表的外鍵--><many-to-one name="customer" cascade="save-update" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>

　　　　測試類

@Test/*** 級聯保存或更新操作：* * 保存聯系人級聯客戶，操作的主體是聯系人對象，需要在LinkMan.hbm.xml中進行配置* * <many-to-one name="customer" cascade="save-update" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>*/public void demo4(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("李兵");LinkMan linkMan = new LinkMan();linkMan.setLkm_name("鳳姐");customer.getLinkMans().add(linkMan);linkMan.setCustomer(customer);session.save(linkMan);tx.commit();}

3、測試對象的導航

　　我們需要注意的是，現在做的屬于雙向關聯，就是客戶關聯聯系人，聯系人也關聯了客戶，其實這種也叫作對象的導航。對象導航是怎么去設置的，怎么往數據庫中保存或更新的。

　　沒有關聯，外鍵默認是 none。

　　對象的導航，一定要搞清楚關聯關系的設置，那邊配置了 cascade 對另一半的影響。

@Test/*** 測試對象的導航* * 前提：一對多的雙方都設置cascade="save-update"*/public void demo5(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("李兵");LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("鳳姐");LinkMan linkMan2 = new LinkMan();linkMan2.setLkm_name("如花");LinkMan linkMan3 = new LinkMan();linkMan3.setLkm_name("芙蓉");linkMan1.setCustomer(customer);customer.getLinkMans().add(linkMan2);customer.getLinkMans().add(linkMan3);// 雙方都設置了cascade// session.save(linkMan1); // 發送幾條insert語句 4條 linkMAn1 custome linkMan2 linkMan2// session.save(customer); // 發送幾條insert語句 3條 customer linkMan2 linkman3session.save(linkMan2); // 發送幾條insert語句 1條 linkMan1 tx.commit();}

5、級聯刪除

　　什么是級聯刪除？

　　　　刪除一邊的，同時將另一方的數據也一并刪除。

　　在 JDBC 情況，要想做級聯刪除，除非先把要刪除的那個客戶（“一”）所關聯的聯系人（“多”）刪除干凈，才能繼續刪除客戶。但是 Hibernate 是可以直接級聯你刪除的。

　　Hibernate 情況將要刪除的外鍵設置為空，再刪除數據，只刪除了一方。

　　Hibernate 刪除數據需要先查詢，再刪除。如果創建對象后直接刪除，這是對象所對應的集合還是空的；先查詢，數據將自動添加到對象所對應的集合，再刪除。

刪除客戶級聯刪除聯系人

@Test/*** 級聯刪除：* * 刪除客戶級聯刪除聯系人，刪除的主體是客戶，需要在Customer.hbm.xml中配置
　　　* * 多個操作之間用逗號隔開* * <set name="linkMans" cascade="save-update,delete">*/public void demo6(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 沒有設置級聯刪除，默認情況:修改了聯系人的外鍵，刪除客戶/*Customer customer = session.get(Customer.class, 1l);session.delete(customer);*/// 刪除客戶，同時刪除聯系人Customer customer = session.get(Customer.class, 1l);session.delete(customer);tx.commit();}

刪除聯系人級聯刪除客戶（基本不用）

@Test/*** 級聯刪除：* * 刪除聯系人級聯刪除客戶，刪除的主體是聯系人，需要在LinkMan.hbm.xml中配置* * <many-to-one name="customer" cascade="delete">*/public void demo7(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 刪除客戶，同時刪除聯系人LinkMan linkMan = session.get(LinkMan.class, 3l);session.delete(linkMan);tx.commit();}

6、一對多設置了雙向關聯產生多余的 SQL 語句

　　在一對多 的操作中，如果設置了雙向關聯，會產生一些多余的 SQL 語句。

　　怎么避免掉這個問題呢？在這里舉一個例子。

　　首先先讓它重新建一下數據庫表，

　　接下來運行 demo1 的程序，往數據表中插入兩個客戶和三個聯系人，讓它重新建議下表。建好以后，再將配置給位 update。

public void demo1(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建兩個客戶Customer customer1 = new Customer();customer1.setCust_name("王東");Customer customer2 = new Customer();customer2.setCust_name("趙洪");// 創建三個聯系人LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("鳳姐");LinkMan linkMan2 = new LinkMan();linkMan2.setLkm_name("如花");LinkMan linkMan3 = new LinkMan();linkMan3.setLkm_name("旺財");// 設置關系: linkMan1.setCustomer(customer1);linkMan2.setCustomer(customer1);linkMan3.setCustomer(customer2);customer1.getLinkMans().add(linkMan1);customer1.getLinkMans().add(linkMan2);customer2.getLinkMans().add(linkMan3);// 保存數據: session.save(linkMan1);session.save(linkMan2);session.save(linkMan3);session.save(customer1);session.save(customer2);tx.commit();}

現在可以在數據庫中看到，兩個客戶和三個聯系人。

原來2號聯系人屬于1號客戶，現在要把它改成屬于2號客戶（沒有用 update 方法，因為兩個對象都是持久態對象，發生改變會自動更新數據可庫）。

@Test/*** 將2號聯系人原來歸1號客戶，現在改為2號客戶*/public void demo8(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 查詢2號聯系人LinkMan linkMan = session.get(LinkMan.class, 2l);// 查詢2號客戶Customer customer = session.get(Customer.class, 2l);// 雙向的關聯 linkMan.setCustomer(customer);customer.getLinkMans().add(linkMan);tx.commit();}

看發送的數據庫語句，數據庫中已經修改成功，發了兩條update語句，兩次都修改了外鍵，為什么會改兩回呢？

當你進行執行的時候，Hibernate 會有一級緩存區，有一塊是緩存區，有一塊是快照區。當你執行 get 查詢的時候，它會將數據放到緩存區一份，并對這份數據進行快照。當事務提交的時候，Hibernate 會比對一級緩存區域和快照區的數據，如果不一致，會更新數據庫。

都會進行更新外鍵，其實只要更新一次外鍵就可以了，所以在這里會產生多余的 SQL 語句

?

解決多余的 SQL語句

　　單向維護，就用一邊去做，比如只讓客戶關聯聯系人，或是只讓聯系人關聯客戶，這么做是可以的。但是這種方法在當前條件下做是可以的，但是有的地方還是不行還是會出現一些問題。

　　還有一種方法是使一方放棄外鍵維護權，為什么會產生多余的 SQL，就是因為現在兩邊都可以維護這個外鍵。

　　因為我們之需要更改一次外鍵就行了，所以必須讓一方放棄外鍵維護權。那么，讓哪一方放棄呢？

　　　　一的一方放棄，為什么一的一方放棄呢。因為關系的維護應當由多的一方發起（讓一個國家主席記住所有人的名字，和所有人記住國家主席的名字）。

　　那怎么讓一的一方放棄呢，就需要在一的一方的配置那，在 set 集合那加上一個配置 inverse，值設置為 true。

?

　　那么放棄外鍵的維護權，在哪個地方還會用到呢？一對多的查詢的修改的時候，現在還沒有做帶頁面的，做帶頁面的時候，既有商品，又有分類。能查出分類，當你查出分類的時候，點擊修改分類時候，會跳到一個界面，有分類的名稱。。然后就提交了，當你提交過去以后，這個集合是空的，因為頁面沒有去提交集合；當你一修改，它會把這個分類下原來所有的商品的外鍵全都改空。這個時候，就必須放棄一的一方的外鍵維護權。

　　減輕了服務器的壓力，少發一些 SQL 語句。

?

?

區分cascade和inverse

@Test/*** 區分cascade和inverse的區別*/public void demo9(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();Customer customer = new Customer();customer.setCust_name("李兵");LinkMan linkMan = new LinkMan();linkMan.setLkm_name("鳳姐");customer.getLinkMans().add(linkMan);// 條件在Customer.hbm.xml上的set中配置了cascade="save-update" inverse="true"session.save(customer); // 客戶會插入到數據庫，聯系人也會插入到數據庫，但是外鍵為null tx.commit();}

　　執行程序，客戶會插入到數據庫，聯系人也會插入到數據庫 ，但是外鍵為空。注意，cascade是操作關聯對象的，也就是客戶進去了，關聯對象（聯系熱人）也會進去，這是由cascade控制的；但是具體有沒有外鍵，是靠inverse去控制的。

Hibernate 的多對多關聯映射

（一）、Hibernate 多對多關系的配置

多對多和一對多還有一點點的淵源，為什么這么說呢？其實就是因為如果你不會多對多，其實你也可以建兩個一對多，也是可以的。

1、創建表

角色表

CREATE TABLE `sys_user` (`user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用戶id',`user_code` varchar(32) NOT NULL COMMENT '用戶賬號',`user_name` varchar(64) NOT NULL COMMENT '用戶名稱',`user_password` varchar(32) NOT NULL COMMENT '用戶密碼',`user_state` char(1) NOT NULL COMMENT '1:正常,0:暫停',PRIMARY KEY (`user_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

用戶表

CREATE TABLE `sys_role` (`role_id` bigint(32) NOT NULL AUTO_INCREMENT,`role_name` varchar(32) NOT NULL COMMENT '角色名稱',`role_memo` varchar(128) DEFAULT NULL COMMENT '備注',PRIMARY KEY (`role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

現在有了用戶表和角色表，一個客戶可以選擇多個角色（多對多關系），所以還需要有一張中間表。中間表就兩個字段，一個是角色 id，一個是用戶 id；分別創建兩個外鍵，分別去指向角色表的主鍵和用戶表的主鍵。

中間表

CREATE TABLE `sys_user_role` (`role_id` bigint(32) NOT NULL COMMENT '角色id',`user_id` bigint(32) NOT NULL COMMENT '用戶id',PRIMARY KEY (`role_id`,`user_id`),KEY `FK_user_role_user_id` (`user_id`),CONSTRAINT `FK_user_role_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`role_id`) ON DELETE NO ACTION ON UPDATE NO ACTION,CONSTRAINT `FK_user_role_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

?2、創建實體

用戶的實體

package com.itheima.hibernate.domain;import java.util.HashSet; import java.util.Set;/*** 用戶的實體* @author jt*CREATE TABLE `sys_user` (`user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用戶id',`user_code` varchar(32) NOT NULL COMMENT '用戶賬號',`user_name` varchar(64) NOT NULL COMMENT '用戶名稱',`user_password` varchar(32) NOT NULL COMMENT '用戶密碼',`user_state` char(1) NOT NULL COMMENT '1:正常,0:暫停',PRIMARY KEY (`user_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;*/ public class User {private Long user_id;private String user_code;private String user_name;private String user_password;private String user_state;// 設置多對多關系：表示一個用戶選擇多個角色？// 放置的是角色的集合private Set<Role> roles = new HashSet<Role>();
// 生成相應的get、setpublic Long getUser_id() {return user_id;}public void setUser_id(Long user_id) {this.user_id = user_id;}public String getUser_code() {return user_code;}public void setUser_code(String user_code) {this.user_code = user_code;}public String getUser_name() {return user_name;}public void setUser_name(String user_name) {this.user_name = user_name;}public String getUser_password() {return user_password;}public void setUser_password(String user_password) {this.user_password = user_password;}public String getUser_state() {return user_state;}public void setUser_state(String user_state) {this.user_state = user_state;}public Set<Role> getRoles() {return roles;}public void setRoles(Set<Role> roles) {this.roles = roles;}}

角色的實體

package com.itheima.hibernate.domain;import java.util.HashSet; import java.util.Set;/*** 角色的實體* @author jt*CREATE TABLE `sys_role` (`role_id` bigint(32) NOT NULL AUTO_INCREMENT,`role_name` varchar(32) NOT NULL COMMENT '角色名稱',`role_memo` varchar(128) DEFAULT NULL COMMENT '備注',PRIMARY KEY (`role_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;*/ public class Role {private Long role_id;private String role_name;private String role_memo;// 一個角色被多個用戶選擇：// 放置的是用戶的集合private Set<User> users = new HashSet<User>();public Long getRole_id() {return role_id;}public void setRole_id(Long role_id) {this.role_id = role_id;}public String getRole_name() {return role_name;}public void setRole_name(String role_name) {this.role_name = role_name;}public String getRole_memo() {return role_memo;}public void setRole_memo(String role_memo) {this.role_memo = role_memo;}public Set<User> getUsers() {return users;}public void setUsers(Set<User> users) {this.users = users;}}

　　現在實體的一些基本的屬性已經建好了，但是現在我們要創建的是一個多對多關系的實體。也就是一個用戶可以選擇多個角色，那么如何去設置多對多的關系呢？多對多關系設置的時候，要想表示之間的關系，放置的都是對方的集合。

3、創建映射

用戶的映射

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping><class name="com.itheima.hibernate.domain.User" table="sys_user"><!-- 建立OID與主鍵的映射 --><id name="user_id" column="user_id"><generator class="native"/></id><!-- 建立普通屬性與字段映射 --><property name="user_code" column="user_code"/><property name="user_name" column="user_name"/><property name="user_password" column="user_password"/><property name="user_state" column="user_state"/><!-- 建立與角色的多對多的映射關系 --><!-- set標簽* name ：對方的集合的屬性名稱。* table ：多對多的關系需要使用中間表，放的是中間表的名稱。--><set name="roles" table="sys_user_role" cascade="save-update,delete" ><!-- key標簽：* column ：當前的對象對應中間表的外鍵的名稱。--><key column="user_id"/><!-- many-to-many標簽：* class ：對方的類的全路徑* column ：對方的對象在中間表中的外鍵的名稱。--><many-to-many class="com.itheima.hibernate.domain.Role" column="role_id"/></set></class> </hibernate-mapping>

角色的映射

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping><class name="com.itheima.hibernate.domain.Role" table="sys_role"><!-- 建立OID與主鍵的映射 --><id name="role_id" column="role_id"><generator class="native"/></id><!-- 建立普通屬性與字段的映射 --><property name="role_name" column="role_name"/><property name="role_memo" column="role_memo"/><!-- 與用戶的多對多的映射關系 --><!-- set標簽* name ：對方的集合的屬性名稱。* table ：多對多的關系需要使用中間表，放的是中間表的名稱。--><set name="users" table="sys_user_role" cascade="save-update,delete" inverse="true"><!-- key標簽：* column ：當前的對象對應中間表的外鍵的名稱。--><key column="role_id"/><!-- many-to-many標簽：* class ：對方的類的全路徑* column ：對方的對象在中間表中的外鍵的名稱。--><many-to-many class="com.itheima.hibernate.domain.User" column="user_id"/></set></class> </hibernate-mapping>

　　映射配置好以后，別忘了，需要把映射文件添加到核心配置里面去 。

<mapping resource="com/itheima/hibernate/domain/User.hbm.xml"/><mapping resource="com/itheima/hibernate/domain/Role.hbm.xml"/>

4、編寫測package com.itheima.hibernate.demo2;import org.hibernate.Session;import org.hibernate.Transaction;import org.junit.Test;

import com.itheima.hibernate.domain.Role; import com.itheima.hibernate.domain.User; import com.itheima.hibernate.utils.HibernateUtils;/*** Hibernate的多對多的映射* @author jt**/ public class HibernateDemo2 {@Test/*** 保存多條記錄：保存多個用戶和角色*/public void demo1(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建2個用戶User user1 = new User();user1.setUser_name("趙洪");User user2 = new User();user2.setUser_name("李兵");// 創建3個角色Role role1 = new Role();role1.setRole_name("研發部");Role role2 = new Role();role2.setRole_name("市場部");Role role3 = new Role();role3.setRole_name("公關部");// 設置雙向的關聯關系: user1.getRoles().add(role1);user1.getRoles().add(role2);user2.getRoles().add(role2);user2.getRoles().add(role3);role1.getUsers().add(user1);
// 獲得用戶的集合，雙向關聯關系就建好了role2.getUsers().add(user1);role2.getUsers().add(user2);role3.getUsers().add(user2);// 保存操作:多對多建立了雙向的關系必須有一方放棄外鍵維護。// 一般是被動方放棄外鍵維護權。 session.save(user1);session.save(user2);
// 角色也要保存，因為沒有配置級聯；session.save(role1);session.save(role2);session.save(role3);
// 這樣一執行，就會出錯（一對多也是這樣設置的，不會出錯）
// 設置了雙向的關聯關系，在一對多的時候，是做了兩次修改，關系維護是靠多的一方的外鍵，修改外鍵就可以了，修改幾次都沒關系；
// 但是，多對多的關系想要去維護，靠的是中間表，中間表關系的維護是往里面插入
// 兩個字段共同決定一條記錄，共同作為主鍵，兩個字段不能同時重復。必須有一方放棄外鍵維護權-
// 一般是被動方放棄外鍵維護權，像我們用戶選角色，角色一般是被動的；所以我們需要在角色這邊的配置里，在set這需要添加inverse=true

// 如果單向關聯，這種是可以的；但有的時候需要雙向關聯，雙向關聯的時候，讓一方放棄就可以了。tx.commit();} }

?

?

多對多的操作，只保存一邊是否可以？不可以，瞬時對象異常
　　如果想要執行，需要設置級聯 @Test/*** 多對多的操作：* * 只保存一邊是否可以？不可以，瞬時對象異常*/public void demo2(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建2個用戶User user1 = new User();user1.setUser_name("趙洪");// 創建3個角色Role role1 = new Role();role1.setRole_name("研發部");// 設置雙向的關聯關系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶：// session.save(user1); session.save(role1);tx.commit();}

?

多對多的級聯保存或更新
　　保存那個對象，外鍵也需要交給它來維護 @Test/*** 多對多的級聯保存：* * 保存用戶級聯保存角色。在用戶的映射文件中配置。* * 在User.hbm.xml中的set上配置 cascade="save-update"*/public void demo3(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建2個用戶User user1 = new User();user1.setUser_name("趙洪");// 創建3個角色Role role1 = new Role();role1.setRole_name("研發部");// 設置雙向的關聯關系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶： session.save(user1);tx.commit();}/*** 多對多的級聯保存：* * 保存角色級聯保存用戶。在角色的映射文件中配置。* * 在Role.hbm.xml中的set上配置 cascade="save-update"*/@Testpublic void demo4(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創建2個用戶User user1 = new User();user1.setUser_name("李兵");// 創建3個角色Role role1 = new Role();role1.setRole_name("公關部");// 設置雙向的關聯關系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶： session.save(role1);tx.commit();}

?

多對多的級聯刪除（基本用不上）

/*** 多對多的級聯刪除：* * 刪除用戶級聯刪除角色* * 在User.hbm.xml中的set上配置 cascade="delete"*/@Testpublic void demo5(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 查詢1號用戶:User user = session.get(User.class, 1l);session.delete(user);tx.commit();}/*** 多對多的級聯刪除：* * 刪除角色級聯刪除用戶* * 在Role.hbm.xml中的set上配置 cascade="delete"*/@Testpublic void demo6(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 查詢2號角色:Role role = session.get(Role.class, 2l);session.delete(role);tx.commit();}

?

給用戶選擇角色，或給用戶改選角色，或是給用戶刪除角色。

@Test/*** 給用戶選擇角色*/public void demo7(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 給1號用戶多選2號角色// 查詢1號用戶User user = session.get(User.class, 1l);// 查詢2號角色Role role = session.get(Role.class, 2l);user.getRoles().add(role);tx.commit();}@Test/*** 給用戶改選角色*/public void demo8(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 給2號用戶將原有的2號角色改為3號角色// 查詢2號用戶User user = session.get(User.class, 2l);// 查詢2號角色Role role2 = session.get(Role.class, 2l);Role role3 = session.get(Role.class, 3l);user.getRoles().remove(role2);user.getRoles().add(role3);tx.commit();}@Test/*** 給用戶改選角色*/public void demo9(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 給2號用戶刪除1號角色// 查詢2號用戶User user = session.get(User.class, 2l);// 查詢2號角色Role role = session.get(Role.class, 1l);user.getRoles().remove(role);tx.commit();}

兩者之間關系的維護，主要靠的是集合。操作集合，就可以操作他們之間的關系，所以說多對多一般進行操作的時候，都操作的是集合。

?

轉載于:https://www.cnblogs.com/xifengbuqi/p/9546276.html

總結

以上是生活随笔為你收集整理的Hibernate（三） - hibernate 表操作-多对多配置的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。