Hibernate映射——一對多關聯映射（七）

時間  2019-11-10
標籤 hibernate 映射 一對多 關聯 欄目 Hibernate 简体版
原文   原文鏈接

一對多關聯映射

 

映射原理

 

      一對多關聯映射和多對一的關聯映射的映射原理是一致的，都是在多的一端加入一個外鍵，指向一的一端。關聯關係都是由多端維護，只是在寫映射時發生了變化。html

 

多對一和一對多的區別

 

         多對一和一對多的區別在於維護的關係不一樣：java

（1）多對一：多端維護一端的關係，在加載多端時，能夠將一端加載上來。app

（2）一對多：一端維護多端的關係，在加載一端時，能夠將多端加載上來。測試

 

分類

 

一對多單向關聯映射

 

對象模型this

          

      從對象模型中，咱們能夠看出，Group持有User的一個引用。因爲是單向關聯，因此數據在加載Group時，會把User加載上來，可是User並不知道Group的存在。spa

 

      咱們先看一下Group和User的實體，以及映射文件。.net

Grouphibernate

[java] view plain copyxml

  1. package com.liang.hibernate;  
  2. import java.util.Set;  
  3. public class Group {  
  4.     private int id;  
  5.     private String name;  
  6.     private Set users;  
  7.       
  8.     public int getId() {  
  9.         return id;  
  10.     }  
  11.     public void setId(int id) {  
  12.         this.id = id;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public Set getUsers() {  
  21.         return users;  
  22.     }  
  23.     public void setUsers(Set users) {  
  24.         this.users = users;  
  25.     }  
  26. }  

Userhtm

[java] view plain copy

  1. package com.liang.hibernate;  
  2.   
  3. public class User {  
  4.     private int id;  
  5.     private String name;  
  6.   
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19. }  

User.hbm.xml

[html] view plain copy

  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. <hibernate-mapping>  
  6.     <class name="com.liang.hibernate.User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.     </class>  
  12. </hibernate-mapping>  

Group.hbm.xml

[html] view plain copy

  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. <hibernate-mapping>  
  6.     <class name="com.liang.hibernate.Group" table="t_group">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- users屬性，表達的是本對象與User的一對多的關係 -->  
  12.         <set name="users">  
  13.              <!--當前表（Group）的主鍵-->  
  14.             <key column="groupid"/>  
  15.             <one-to-many class="com.liang.hibernate.User"/>  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  

生成的表結構和測試數據

缺點

 

1）由於多端User不知道Group的存在（也就是User不維護與Group的關係），因此在保存User時，關係字段groupId爲null，若是該字段設置爲非空，則將沒法保存數據。

2）由於User不維護關係，而Group維護關係，Group就會發出多餘的update語句，保證Group和User有關係，這樣加載Group時才把該Users對應的用戶加載上來。

 

一對多雙向關聯映射

 

對象模型

           

        雙向關聯映射對比單向關聯映射，對象的加載方向由單向變成了雙向。

 

咱們看一下Group和User的實體，映射文件

Group

[java] view plain copy

  1. package com.liang.hibernate;  
  2.   
  3. import java.util.Set;  
  4.   
  5. public class Group {  
  6.     private int id;  
  7.     private String name;  
  8.     private Set users;  
  9.   
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public Set getUsers() {  
  23.         return users;  
  24.     }  
  25.     public void setUsers(Set users) {  
  26.         this.users = users;  
  27.     }  
  28. }  

User

[java] view plain copy

  1. package com.liang.hibernate;  
  2.   
  3. public class User {  
  4.     private int id;  
  5.     private String name;  
  6.     private Group groups;  
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getName() {  
  14.         return name;  
  15.     }  
  16.     public void setName(String name) {  
  17.         this.name = name;  
  18.     }  
  19.     public Group getGroups() {  
  20.         return groups;  
  21.     }  
  22.     public void setGroups(Group groups) {  
  23.         this.groups = groups;  
  24.     }  
  25. }  

Group.hbm.xml

[html] view plain copy

  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. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="Group" table="t_group">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- 影響控制反轉：inverse="false",多的一端維護關係，讓一的一端失效 -->  
  12.         <set name="users" inverse="true">  
  13.             <key column="groupid" not-null="true"/>  
  14.             <one-to-many class="User"/>  
  15.         </set>  
  16.     </class>  
  17. </hibernate-mapping>  

User.hbm.xml

[html] view plain copy

  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. <hibernate-mapping package="com.liang.hibernate">  
  6.     <class name="User" table="t_user">  
  7.         <id name="id">  
  8.             <generator class="native"/>  
  9.         </id>  
  10.         <property name="name"/>  
  11.         <!-- groups屬性，表達的是本對象與Group的多對一的關係 -->  
  12.         <many-to-one name="groups" class="Group" column="groupid"/>  
  13.     </class>  
  14. </hibernate-mapping>  

生成的表和測試數據

 

一對多雙向關聯的映射方式：
 1）在一的一端的集合上採用<key>標籤，在多的一端加入一個外鍵
 2）在多的一端採用<many-to-one>標籤

注意：<key>標籤和<many-to-one>標籤加入的字段保持一直，不然會產生數據混亂。

inverse屬性：

         inverse屬性能夠用在一對多和多對多雙向關聯上，inverse屬性默認爲false，爲false表示本端維護關係，若是inverse爲true，則本端不能維護關係，會交給另外一端維護關係，本端失效。因此一對多關聯映射咱們一般在多的一端維護關係，讓一的一端失效，因此設置爲inverse爲true。

注意：inverse屬性，隻影響數據的存儲，也就是持久化。

 

目的

 

       一對多雙向關聯映射的目的主要是爲了解決一對多單向關聯的缺陷而不是需求驅動的。

 

總結

 

     一對多關聯映射仍是很簡單的，下篇博文咱們介紹多對多關聯映射。謝謝關注。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程