Hibernate（三） - hibernate 表操作-多对多配置
Hibernate 的一對多關(guān)聯(lián)映射
之前在學(xué)習(xí) Hibernate 的時候，其實(shí)都是單表的操作。在實(shí)際的開發(fā)當(dāng)中，比如做一個商城，就需要好多張數(shù)據(jù)庫表，表與表之間是有關(guān)系的。之前些做一些關(guān)聯(lián)查詢或者是一些基本的查詢操作的時候，都是寫 SQL 語句去關(guān)聯(lián)兩張表，這樣子稍微有一點(diǎn)麻煩。那么有了 Hibernate? 之后，它就可以解決這類問題了。在這之前，先了解一些數(shù)據(jù)庫 表之間的關(guān)系，它是有三種關(guān)系的。
1、數(shù)據(jù)庫表與表之間的關(guān)系?
也就是說我們的一個系統(tǒng)，抽取出來的那些實(shí)體，因?yàn)楸硎歉鶕?jù)實(shí)體來的 ，那么它會根據(jù)實(shí)體分成 這三類的關(guān)系。也就是說你所有的系統(tǒng)里邊，所有抽取出來的實(shí)體，也只有這三種關(guān)系。
① 一對多的關(guān)系
什么關(guān)系屬于一對多？
一個部門對于多個員工，一個員工只能屬于一個部門。
一個客戶可以對應(yīng)多個聯(lián)系人，一個聯(lián)系人只能屬于某一個客戶（個人認(rèn)為是錯誤的）。
一對多的創(chuàng)表原則
② 多對多的關(guān)系
什么樣的關(guān)系屬于多對多？
一個學(xué)生可以選擇多門課程，一門課程也可以被多個學(xué)生選擇。
一個用戶可以選擇多個角色，一個角色也可以被多個用戶選擇。
多對多建表原則
③ 一對一的關(guān)系（了解，實(shí)際開發(fā)過程中應(yīng)用很少）
在實(shí)際開發(fā)過程中，一對一的關(guān)系可以建成一張表，除非 是有特殊的需求需要將表分開。
唯一外鍵對應(yīng)
在一張表添加外鍵字段，并作唯一約束。
主鍵對應(yīng)
需要將兩張表關(guān)聯(lián)。
?一對多怎么表示？一個客戶應(yīng)該有多個聯(lián)系人，一個聯(lián)系人只能屬于一個客戶。
現(xiàn)在要通過 ORM 的方式表示：一個聯(lián)系人只能屬于某一個客戶。開發(fā)語言是面向?qū)ο蟮?，怎么表示一個聯(lián)系人屬于一個客戶呢？放置一個客戶的對象，所有以后創(chuàng)表的時候會創(chuàng)建外鍵，但是創(chuàng)建實(shí)體的時候要放的是“一”的一方的一個對象。所以以后碰到外鍵的時候不要寫外鍵的名稱了，把外鍵改成“一”的一個對象，并生成相應(yīng)的get & set。
還是通過 ORM 的方式表示 ：一個客戶對應(yīng)多個聯(lián)系人。放置的是“多”的一方的集合。需要注意的是，hibernate 默認(rèn)使用的是 set 集合，不是 list 集合。當(dāng)然，它里面也可以配置 list/map，list 集合應(yīng)為在 hibernate 中需要對 list 數(shù)據(jù)進(jìn)行有序排列。如果配置 list 集合，hibernate 需要在數(shù)據(jù)庫表中多建一列，這一列就是用于 hibernate 排序的，它會用0、1、2、3、4、5...列這個順序，那么表會多出來一列。所以一般是使用的都是 set 集合。
現(xiàn)在做的是雙向關(guān)聯(lián)，就是從客戶這邊查聯(lián)系人可以查，從聯(lián)系人這邊查客戶也可以查。如果只做了單向關(guān)聯(lián)，只在聯(lián)系人那邊放客戶對象了，客戶這邊沒有放聯(lián)系人的集合，那你在查詢的時候，只能從聯(lián)系人查到客戶，就不能從客戶查聯(lián)系人了。當(dāng)然，兩邊都做好了，想從那邊去查都沒問題（也可以做出單項(xiàng)的）。
Hibernate 的一對多關(guān)聯(lián)映射
（一）、Hibernate 的一對多關(guān)聯(lián)映射
1、創(chuàng)建一個項(xiàng)目，引入相應(yīng) jar 包
2、創(chuàng)建數(shù)據(jù)庫和表
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 '客戶所屬行業(yè)',`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 '聯(lián)系人編號(主鍵)',`lkm_name` varchar(16) DEFAULT NULL COMMENT '聯(lián)系人姓名',`lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客戶id',`lkm_gender` char(1) DEFAULT NULL COMMENT '聯(lián)系人性別',`lkm_phone` varchar(16) DEFAULT NULL COMMENT '聯(lián)系人辦公電話',`lkm_mobile` varchar(16) DEFAULT NULL COMMENT '聯(lián)系人手機(jī)',`lkm_email` varchar(64) DEFAULT NULL COMMENT '聯(lián)系人郵箱',`lkm_qq` varchar(16) DEFAULT NULL COMMENT '聯(lián)系人qq',`lkm_position` varchar(16) DEFAULT NULL COMMENT '聯(lián)系人職位',`lkm_memo` varchar(512) DEFAULT NULL COMMENT '聯(lián)系人備注',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 數(shù)據(jù)庫中，將兩張表拖拽到“架構(gòu)設(shè)計器”選項(xiàng)卡就可以看到兩張表之間的關(guān)系。
3、創(chuàng)建實(shí)體
① “一”的一方的實(shí)體
② “多的一方的實(shí)體”
4、創(chuàng)建映射文件
① 多的一方的映射的創(chuàng)建（聯(lián)系人表的 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"/><!-- 配置多對一的關(guān)系：放置的是一的一方的對象 --><!-- many-to-one標(biāo)簽* name :一的一方的對象的屬性名稱。* class :一的一方的類的全路徑。* column :在多的一方的表的外鍵的名稱。操作 column 就相當(dāng)與操作數(shù)據(jù)庫中表的外鍵--><many-to-one name="customer" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/></class> </hibernate-mapping>
② “一”的一方的映射的創(chuàng)建（客戶表的 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><!-- 建立普通屬性與數(shù)據(jù)庫表字段映射 --><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標(biāo)簽 ：* name ：多的一方的對象集合的屬性名稱。* cascade：級聯(lián)* inverse：放棄外鍵維護(hù)權(quán)。--><set name="linkMans"><!--key標(biāo)簽* column：多的一方的外鍵的名稱。--><key column="lkm_cust_id"/><!-- one-to-many標(biāo)簽* class :多的一方的類的全路徑--><one-to-many class="com.itheima.hibernate.domain.LinkMan"/></set></class> </hibernate-mapping>5、創(chuàng)建核心配置文件（hibernate.cfg.xml）
將要連接的數(shù)據(jù)庫名稱改一下，還有要引入的映射文件，這里要引入兩個映射文件。
<?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><!-- 連接數(shù)據(jù)庫的基本參數(shù) --><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><!-- 自動創(chuàng)建表 --><property name="hibernate.hbm2ddl.auto">update</property><!-- 配置C3P0連接池 --><property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property><!--在連接池中可用的數(shù)據(jù)庫連接的最少數(shù)目 --><property name="c3p0.min_size">5</property><!--在連接池中所有數(shù)據(jù)庫連接的最大數(shù)目 --><property name="c3p0.max_size">20</property><!--設(shè)定數(shù)據(jù)庫連接的過期時間,以秒為單位,如果連接池中的某個數(shù)據(jù)庫連接處于空閑狀態(tài)的時間超過了timeout時間,就會從連接池中清除 --><property name="c3p0.timeout">120</property><!--每3000秒檢查所有連接池中的空閑連接 以秒為單位--><property name="c3p0.idle_test_period">3000</property><!-- 設(shè)置事務(wù)隔離級別 --><property name="hibernate.connection.isolation">4</property><!-- 配置當(dāng)前線程綁定的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、創(chuàng)建測試類
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個聯(lián)系人 并且建立好關(guān)系public void demo1(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創(chuàng)建兩個客戶Customer customer1 = new Customer();customer1.setCust_name("王東");Customer customer2 = new Customer();customer2.setCust_name("趙洪");// 創(chuàng)建三個聯(lián)系人LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("鳳姐");LinkMan linkMan2 = new LinkMan();linkMan2.setLkm_name("如花");LinkMan linkMan3 = new LinkMan();linkMan3.setLkm_name("旺財");// 設(shè)置關(guān)系: linkMan1.setCustomer(customer1);linkMan2.setCustomer(customer1);linkMan3.setCustomer(customer2);customer1.getLinkMans().add(linkMan1);customer1.getLinkMans().add(linkMan2);customer2.getLinkMans().add(linkMan3);// 保存數(shù)據(jù): session.save(linkMan1);session.save(linkMan2);session.save(linkMan3);session.save(customer1);session.save(customer2);tx.commit();} @Test/*** 區(qū)分cascade和inverse的區(qū)別*/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); // 客戶會插入到數(shù)據(jù)庫，聯(lián)系人也會插入到數(shù)據(jù)庫，但是外鍵為null tx.commit();} }（二）、Hibernate 的一對多相關(guān)操作
1、一對多關(guān)系只保存一邊是否可行?
將數(shù)據(jù)做了雙向關(guān)連以后，是否可以 只保存一邊的 數(shù)據(jù)呢？不可以，回報一個瞬時對象異常的錯誤。什么是瞬時對象異常啊，就是說持久態(tài)的對象關(guān)聯(lián)了一個瞬時態(tài)的對象。客戶對象本來是瞬時態(tài)的對象 ，一保存就變成持久態(tài)的對象了，之前和聯(lián)系人對象做了關(guān)聯(lián)，但聯(lián)系人對象 還是瞬時態(tài)的對象，所以會報錯。
@Test// 一對多關(guān)系只保存一邊是否可以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);// 只保存一邊是否可以：不可以，報一個瞬時對象異常：持久態(tài)對象關(guān)聯(lián)了一個瞬時態(tài)對象。// session.save(customer); session.save(linkMan);tx.commit();}2、一對多的級聯(lián)操作
如果想只保存一邊，那么要通過一個配置，叫做級聯(lián)操作。
級聯(lián)操作包含有常用的兩種級聯(lián)操作，一種叫級聯(lián)保存或更新，一種叫級聯(lián)刪除。
什么叫做級聯(lián)
級聯(lián)指的是，操作一個對象的時候，是否會同時操作其關(guān)聯(lián)的對象。
? 級聯(lián)是有方向性
操作一的一方的時候，是否操作到多的一方
操作多的一方的時候，是否操作到一的一方
之前保存一邊是會報異常的，報的是瞬時對象異常。現(xiàn)在要通過配置完成一個級聯(lián)操作，要看你操作的主體是什么，我們現(xiàn)在操作的主體是 客戶對象，需要在客戶實(shí)體的映射文件中進(jìn)行配置 。
① 級聯(lián)保存或更新
保存客戶級聯(lián)聯(lián)系人（保存“一”的一方，級聯(lián)“多”的一方）
映射文件的配置
<!-- set標(biāo)簽 ：* name ：多的一方的對象集合的屬性名稱。* cascade：級聯(lián)* inverse：放棄外鍵維護(hù)權(quán)。--><set name="linkMans" cascade="save-update">測試類
@Test/*** 級聯(lián)保存或更新操作：* * 保存客戶級聯(lián)聯(lián)系人，操作的主體是客戶對象，需要在Customer.hbm.xml中進(jìn)行配置* * <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();}保存聯(lián)系人級聯(lián)客戶（保存“多”的一方，級聯(lián)“一”的一方）
映射文件的配置
<!-- many-to-one標(biāo)簽* name :一的一方的對象的屬性名稱。* class :一的一方的類的全路徑。* column :在多的一方的表的外鍵的名稱。操作 column 就相當(dāng)與操作數(shù)據(jù)庫中表的外鍵--><many-to-one name="customer" cascade="save-update" class="com.itheima.hibernate.domain.Customer" column="lkm_cust_id"/>測試類
@Test/*** 級聯(lián)保存或更新操作：* * 保存聯(lián)系人級聯(lián)客戶，操作的主體是聯(lián)系人對象，需要在LinkMan.hbm.xml中進(jìn)行配置* * <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、測試對象的導(dǎo)航
我們需要注意的是，現(xiàn)在做的屬于雙向關(guān)聯(lián)，就是客戶關(guān)聯(lián)聯(lián)系人，聯(lián)系人也關(guān)聯(lián)了客戶，其實(shí)這種也叫作對象的導(dǎo)航。對象導(dǎo)航是怎么去設(shè)置的，怎么往數(shù)據(jù)庫中保存或更新的。
沒有關(guān)聯(lián)，外鍵默認(rèn)是 none。
對象的導(dǎo)航，一定要搞清楚關(guān)聯(lián)關(guān)系的設(shè)置，那邊配置了 cascade 對另一半的影響。
@Test/*** 測試對象的導(dǎo)航* * 前提：一對多的雙方都設(shè)置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);// 雙方都設(shè)置了cascade// session.save(linkMan1); // 發(fā)送幾條insert語句 4條 linkMAn1 custome linkMan2 linkMan2// session.save(customer); // 發(fā)送幾條insert語句 3條 customer linkMan2 linkman3session.save(linkMan2); // 發(fā)送幾條insert語句 1條 linkMan1 tx.commit();}5、級聯(lián)刪除
什么是級聯(lián)刪除？
刪除一邊的，同時將另一方的數(shù)據(jù)也一并刪除。
在 JDBC 情況，要想做級聯(lián)刪除，除非先把要刪除的那個客戶（“一”）所關(guān)聯(lián)的聯(lián)系人（“多”）刪除干凈，才能繼續(xù)刪除客戶。但是 Hibernate 是可以直接級聯(lián)你刪除的。
Hibernate 情況將要刪除的外鍵設(shè)置為空，再刪除數(shù)據(jù)，只刪除了一方。
Hibernate 刪除數(shù)據(jù)需要先查詢，再刪除。如果創(chuàng)建對象后直接刪除，這是對象所對應(yīng)的集合還是空的；先查詢，數(shù)據(jù)將自動添加到對象所對應(yīng)的集合，再刪除。
刪除客戶級聯(lián)刪除聯(lián)系人
@Test/*** 級聯(lián)刪除：* * 刪除客戶級聯(lián)刪除聯(lián)系人，刪除的主體是客戶，需要在Customer.hbm.xml中配置* * 多個操作之間用逗號隔開* * <set name="linkMans" cascade="save-update,delete">*/public void demo6(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 沒有設(shè)置級聯(lián)刪除，默認(rèn)情況:修改了聯(lián)系人的外鍵，刪除客戶/*Customer customer = session.get(Customer.class, 1l);session.delete(customer);*/// 刪除客戶，同時刪除聯(lián)系人Customer customer = session.get(Customer.class, 1l);session.delete(customer);tx.commit();}
刪除聯(lián)系人級聯(lián)刪除客戶（基本不用）
@Test/*** 級聯(lián)刪除：* * 刪除聯(lián)系人級聯(lián)刪除客戶，刪除的主體是聯(lián)系人，需要在LinkMan.hbm.xml中配置* * <many-to-one name="customer" cascade="delete">*/public void demo7(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 刪除客戶，同時刪除聯(lián)系人LinkMan linkMan = session.get(LinkMan.class, 3l);session.delete(linkMan);tx.commit();}6、一對多設(shè)置了雙向關(guān)聯(lián)產(chǎn)生多余的 SQL 語句
在一對多 的操作中，如果設(shè)置了雙向關(guān)聯(lián)，會產(chǎn)生一些多余的 SQL 語句。
怎么避免掉這個問題呢？在這里舉一個例子。
首先先讓它重新建一下數(shù)據(jù)庫表，
接下來運(yùn)行 demo1 的程序，往數(shù)據(jù)表中插入兩個客戶和三個聯(lián)系人，讓它重新建議下表。建好以后，再將配置給位 update。
public void demo1(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創(chuàng)建兩個客戶Customer customer1 = new Customer();customer1.setCust_name("王東");Customer customer2 = new Customer();customer2.setCust_name("趙洪");// 創(chuàng)建三個聯(lián)系人LinkMan linkMan1 = new LinkMan();linkMan1.setLkm_name("鳳姐");LinkMan linkMan2 = new LinkMan();linkMan2.setLkm_name("如花");LinkMan linkMan3 = new LinkMan();linkMan3.setLkm_name("旺財");// 設(shè)置關(guān)系: linkMan1.setCustomer(customer1);linkMan2.setCustomer(customer1);linkMan3.setCustomer(customer2);customer1.getLinkMans().add(linkMan1);customer1.getLinkMans().add(linkMan2);customer2.getLinkMans().add(linkMan3);// 保存數(shù)據(jù): session.save(linkMan1);session.save(linkMan2);session.save(linkMan3);session.save(customer1);session.save(customer2);tx.commit();}現(xiàn)在可以在數(shù)據(jù)庫中看到，兩個客戶和三個聯(lián)系人。
原來2號聯(lián)系人屬于1號客戶，現(xiàn)在要把它改成屬于2號客戶（沒有用 update 方法，因?yàn)閮蓚€對象都是持久態(tài)對象，發(fā)生改變會自動更新數(shù)據(jù)可庫）。
@Test/*** 將2號聯(lián)系人原來歸1號客戶，現(xiàn)在改為2號客戶*/public void demo8(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 查詢2號聯(lián)系人LinkMan linkMan = session.get(LinkMan.class, 2l);// 查詢2號客戶Customer customer = session.get(Customer.class, 2l);// 雙向的關(guān)聯(lián) linkMan.setCustomer(customer);customer.getLinkMans().add(linkMan);tx.commit();}看發(fā)送的數(shù)據(jù)庫語句，數(shù)據(jù)庫中已經(jīng)修改成功，發(fā)了兩條update語句，兩次都修改了外鍵，為什么會改兩回呢？
當(dāng)你進(jìn)行執(zhí)行的時候，Hibernate 會有一級緩存區(qū)，有一塊是緩存區(qū)，有一塊是快照區(qū)。當(dāng)你執(zhí)行 get 查詢的時候，它會將數(shù)據(jù)放到緩存區(qū)一份，并對這份數(shù)據(jù)進(jìn)行快照。當(dāng)事務(wù)提交的時候，Hibernate 會比對一級緩存區(qū)域和快照區(qū)的數(shù)據(jù)，如果不一致，會更新數(shù)據(jù)庫。
都會進(jìn)行更新外鍵，其實(shí)只要更新一次外鍵就可以了，所以在這里會產(chǎn)生多余的 SQL 語句
?
解決多余的 SQL語句
單向維護(hù)，就用一邊去做，比如只讓客戶關(guān)聯(lián)聯(lián)系人，或是只讓聯(lián)系人關(guān)聯(lián)客戶，這么做是可以的。但是這種方法在當(dāng)前條件下做是可以的，但是有的地方還是不行還是會出現(xiàn)一些問題。
還有一種方法是使一方放棄外鍵維護(hù)權(quán)，為什么會產(chǎn)生多余的 SQL，就是因?yàn)楝F(xiàn)在兩邊都可以維護(hù)這個外鍵。
因?yàn)槲覀冎枰囊淮瓮怄I就行了，所以必須讓一方放棄外鍵維護(hù)權(quán)。那么，讓哪一方放棄呢？
一的一方放棄，為什么一的一方放棄呢。因?yàn)殛P(guān)系的維護(hù)應(yīng)當(dāng)由多的一方發(fā)起（讓一個國家主席記住所有人的名字，和所有人記住國家主席的名字）。
那怎么讓一的一方放棄呢，就需要在一的一方的配置那，在 set 集合那加上一個配置 inverse，值設(shè)置為 true。
?
那么放棄外鍵的維護(hù)權(quán)，在哪個地方還會用到呢？一對多的查詢的修改的時候，現(xiàn)在還沒有做帶頁面的，做帶頁面的時候，既有商品，又有分類。能查出分類，當(dāng)你查出分類的時候，點(diǎn)擊修改分類時候，會跳到一個界面，有分類的名稱。。然后就提交了，當(dāng)你提交過去以后，這個集合是空的，因?yàn)轫撁鏇]有去提交集合；當(dāng)你一修改，它會把這個分類下原來所有的商品的外鍵全都改空。這個時候，就必須放棄一的一方的外鍵維護(hù)權(quán)。
減輕了服務(wù)器的壓力，少發(fā)一些 SQL 語句。
?
?
區(qū)分cascade和inverse
@Test/*** 區(qū)分cascade和inverse的區(qū)別*/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); // 客戶會插入到數(shù)據(jù)庫，聯(lián)系人也會插入到數(shù)據(jù)庫，但是外鍵為null tx.commit();}執(zhí)行程序，客戶會插入到數(shù)據(jù)庫，聯(lián)系人也會插入到數(shù)據(jù)庫 ，但是外鍵為空。注意，cascade是操作關(guān)聯(lián)對象的，也就是客戶進(jìn)去了，關(guān)聯(lián)對象（聯(lián)系熱人）也會進(jìn)去，這是由cascade控制的；但是具體有沒有外鍵，是靠inverse去控制的。
Hibernate 的多對多關(guān)聯(lián)映射
（一）、Hibernate 多對多關(guān)系的配置
多對多和一對多還有一點(diǎn)點(diǎn)的淵源，為什么這么說呢？其實(shí)就是因?yàn)槿绻悴粫鄬Χ?#xff0c;其實(shí)你也可以建兩個一對多，也是可以的。
1、創(chuàng)建表
角色表
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;現(xiàn)在有了用戶表和角色表，一個客戶可以選擇多個角色（多對多關(guān)系），所以還需要有一張中間表。中間表就兩個字段，一個是角色 id，一個是用戶 id；分別創(chuàng)建兩個外鍵，分別去指向角色表的主鍵和用戶表的主鍵。
中間表
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、創(chuàng)建實(shí)體
用戶的實(shí)體
package com.itheima.hibernate.domain;import java.util.HashSet; import java.util.Set;/*** 用戶的實(shí)體* @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;// 設(shè)置多對多關(guān)系：表示一個用戶選擇多個角色？// 放置的是角色的集合private Set<Role> roles = new HashSet<Role>();// 生成相應(yīng)的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;}}
角色的實(shí)體
package com.itheima.hibernate.domain;import java.util.HashSet; import java.util.Set;/*** 角色的實(shí)體* @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;}}現(xiàn)在實(shí)體的一些基本的屬性已經(jīng)建好了，但是現(xiàn)在我們要創(chuàng)建的是一個多對多關(guān)系的實(shí)體。也就是一個用戶可以選擇多個角色，那么如何去設(shè)置多對多的關(guān)系呢？多對多關(guān)系設(shè)置的時候，要想表示之間的關(guān)系，放置的都是對方的集合。
3、創(chuàng)建映射
用戶的映射
<?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"/><!-- 建立與角色的多對多的映射關(guān)系 --><!-- set標(biāo)簽* name ：對方的集合的屬性名稱。* table ：多對多的關(guān)系需要使用中間表，放的是中間表的名稱。--><set name="roles" table="sys_user_role" cascade="save-update,delete" ><!-- key標(biāo)簽：* column ：當(dāng)前的對象對應(yīng)中間表的外鍵的名稱。--><key column="user_id"/><!-- many-to-many標(biāo)簽：* 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"/><!-- 與用戶的多對多的映射關(guān)系 --><!-- set標(biāo)簽* name ：對方的集合的屬性名稱。* table ：多對多的關(guān)系需要使用中間表，放的是中間表的名稱。--><set name="users" table="sys_user_role" cascade="save-update,delete" inverse="true"><!-- key標(biāo)簽：* column ：當(dāng)前的對象對應(yīng)中間表的外鍵的名稱。--><key column="role_id"/><!-- many-to-many標(biāo)簽：* 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();// 創(chuàng)建2個用戶User user1 = new User();user1.setUser_name("趙洪");User user2 = new User();user2.setUser_name("李兵");// 創(chuàng)建3個角色Role role1 = new Role();role1.setRole_name("研發(fā)部");Role role2 = new Role();role2.setRole_name("市場部");Role role3 = new Role();role3.setRole_name("公關(guān)部");// 設(shè)置雙向的關(guān)聯(lián)關(guān)系: user1.getRoles().add(role1);user1.getRoles().add(role2);user2.getRoles().add(role2);user2.getRoles().add(role3);role1.getUsers().add(user1);// 獲得用戶的集合，雙向關(guān)聯(lián)關(guān)系就建好了role2.getUsers().add(user1);role2.getUsers().add(user2);role3.getUsers().add(user2);// 保存操作:多對多建立了雙向的關(guān)系必須有一方放棄外鍵維護(hù)。// 一般是被動方放棄外鍵維護(hù)權(quán)。 session.save(user1);session.save(user2);
// 角色也要保存，因?yàn)闆]有配置級聯(lián)；session.save(role1);session.save(role2);session.save(role3);
// 這樣一執(zhí)行，就會出錯（一對多也是這樣設(shè)置的，不會出錯）
// 設(shè)置了雙向的關(guān)聯(lián)關(guān)系，在一對多的時候，是做了兩次修改，關(guān)系維護(hù)是靠多的一方的外鍵，修改外鍵就可以了，修改幾次都沒關(guān)系；
// 但是，多對多的關(guān)系想要去維護(hù)，靠的是中間表，中間表關(guān)系的維護(hù)是往里面插入
// 兩個字段共同決定一條記錄，共同作為主鍵，兩個字段不能同時重復(fù)。必須有一方放棄外鍵維護(hù)權(quán)-
// 一般是被動方放棄外鍵維護(hù)權(quán)，像我們用戶選角色，角色一般是被動的；所以我們需要在角色這邊的配置里，在set這需要添加inverse=true
// 如果單向關(guān)聯(lián)，這種是可以的；但有的時候需要雙向關(guān)聯(lián)，雙向關(guān)聯(lián)的時候，讓一方放棄就可以了。tx.commit();} }
?
?
多對多的操作，只保存一邊是否可以？不可以，瞬時對象異常如果想要執(zhí)行，需要設(shè)置級聯(lián) @Test/*** 多對多的操作：* * 只保存一邊是否可以？不可以，瞬時對象異常*/public void demo2(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創(chuàng)建2個用戶User user1 = new User();user1.setUser_name("趙洪");// 創(chuàng)建3個角色Role role1 = new Role();role1.setRole_name("研發(fā)部");// 設(shè)置雙向的關(guān)聯(lián)關(guān)系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶：// session.save(user1); session.save(role1);tx.commit();}
?
多對多的級聯(lián)保存或更新保存那個對象，外鍵也需要交給它來維護(hù) @Test/*** 多對多的級聯(lián)保存：* * 保存用戶級聯(lián)保存角色。在用戶的映射文件中配置。* * 在User.hbm.xml中的set上配置 cascade="save-update"*/public void demo3(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創(chuàng)建2個用戶User user1 = new User();user1.setUser_name("趙洪");// 創(chuàng)建3個角色Role role1 = new Role();role1.setRole_name("研發(fā)部");// 設(shè)置雙向的關(guān)聯(lián)關(guān)系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶： session.save(user1);tx.commit();}/*** 多對多的級聯(lián)保存：* * 保存角色級聯(lián)保存用戶。在角色的映射文件中配置。* * 在Role.hbm.xml中的set上配置 cascade="save-update"*/@Testpublic void demo4(){Session session = HibernateUtils.getCurrentSession();Transaction tx = session.beginTransaction();// 創(chuàng)建2個用戶User user1 = new User();user1.setUser_name("李兵");// 創(chuàng)建3個角色Role role1 = new Role();role1.setRole_name("公關(guān)部");// 設(shè)置雙向的關(guān)聯(lián)關(guān)系: user1.getRoles().add(role1);role1.getUsers().add(user1);// 只保存用戶： session.save(role1);tx.commit();}
?
多對多的級聯(lián)刪除（基本用不上）
/*** 多對多的級聯(lián)刪除：* * 刪除用戶級聯(lián)刪除角色* * 在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();}/*** 多對多的級聯(lián)刪除：* * 刪除角色級聯(lián)刪除用戶* * 在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();}兩者之間關(guān)系的維護(hù)，主要靠的是集合。操作集合，就可以操作他們之間的關(guān)系，所以說多對多一般進(jìn)行操作的時候，都操作的是集合。
?
轉(zhuǎn)載于:https://www.cnblogs.com/xifengbuqi/p/9546276.html
總結(jié)
以上是生活随笔為你收集整理的Hibernate（三） - hibernate 表操作-多对多配置的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： win7 64安装工商网银U盾软件
- 下一篇： modscan32做主站 一直显示MOD