• SSH：Hibernate框架（七种关联关系映射及配置详解）

    概念

           基本映射是对一个实体进行映射，关联映射就是处理多个实体之间的关系，将关联关系映射到数据库中，所谓的关联关系在对象模型中有一个或多个引用。

    分类


             

                

            关联关系分为上述七种，但是由于相互之间有各种关系，可以简化，例如：多对一与一对多映射，只是侧重的角度不对而已。

    映射技巧

           映射技巧是小编写映射文件的过程，总结的经典内容，总共分为四步，咋看不是特别易懂，但是效果很好。下面我们以实例看技巧。

    （1）写注释

             格式为：？属性，表达的是本对象与？的？关系。

             解释：在写映射文件之前先写注释，将问号的地方填上相应的内容。例如：<!-- group属性，表达的是本对象（User）与Group的多对一的关系-->

    （2）写映射的框架（拷模版）

    多对一

    <many-to-one name=“” class=“” column=“”/>

    一对多

    （Set）

    <set name="">

            <key column=""></key>

            <one-to-many class=""/>

    </set>

    多对多

    （Set）

    <set name="" table="">

            <key column=""></key>

            <many-to-many class="" column=""/>

    </set>

    （3）填空

              填空，就是将映射的框架信息，填写完成，完成映射文件。

              • name属性：属性名（注释中的第1问号）
              • class属性：关联的实体类型（注释中的第2个问号）
              • column属性：
                   ○ <many-to-one column="..">：一般可以写成属性名加Id后缀，如属性为group，则column值写成groupId。
                   ○ 一对多中的<key column="..">：从关联的对方（对方是多对一）映射中把column值拷贝过来。 
                   ○ 多对多中的<key column=“..”>：一般可以写成本对象的名加Id后缀，如本对象名为User，则写为userId。
                   ○ 多对多中的<many-to-many column=“..”>：一般可以写为关联对象的名称加Id后缀。
     

    （4）完成

              将映射文件添加到hibernate.hbm.xml中，这个相信大家都知道为什么。

          

              我们后面所有关联映射的博文都使用此映射技巧来写映射文件，明白之后，速度会非常快。

    （一）多对一关联映射
     

    映射原理

           多的一端维护关联关系，在“多”的一端加入一个外键，指向“一”的一端。多的一端持有一的一端的引用，即在“多”的一端加外键，指向“一”的一端。

    实例

           比如，多个用户属于同一组，我们从对象模型和关系模型两个角度来分析一下这个例子，如下：

          从上图可以看出，对象模型具有方向性，通过用户（User）可以看到组（Group），但是不能反过来。用户和组各对应一张数据库表，聚合关系需要一个外键（groupid）来表示，最后生成的表如下所示：

    作用：

          当我拿到用户时直接就可以拿到用户的组，hibernate在访问多的一端时，可以自动的加载关联对象。对于用户（User）来说，它的关联对象是组（group）。

          上面都是多对一关联映射的基本原理，以及相应的实例，下面我们看一下代码：

     代码

    User类

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. public class User {  
    2.     private int id;  
    3.     private String name;  
    4.     private Group group;  
    5.           
    6.     public int getId() {  
    7.         return id;  
    8.     }  
    9.     public void setId(int id) {  
    10.         this.id = id;  
    11.     }  
    12.     public String getName() {  
    13.         return name;  
    14.     }  
    15.     public void setName(String name) {  
    16.         this.name = name;  
    17.     }  
    18.     public Group getGroup() {  
    19.         return group;  
    20.     }  
    21.     public void setGroup(Group group) {  
    22.         this.group = group;  
    23.     }  
    24. }  

    Group类

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. public class Group {  
    2.     private int id;  
    3.     private String name;  
    4.     public int getId() {  
    5.         return id;  
    6.     }  
    7.     public void setId(int id) {  
    8.         this.id = id;  
    9.     }  
    10.     public String getName() {  
    11.         return name;  
    12.     }  
    13.     public void setName(String name) {  
    14.         this.name = name;  
    15.     }  

    User.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- group属性，表达的是本对象与Group的多对一的关系-->  
    12.         <many-to-one name="group" class="Group" column="groupid"></many-to-one>  
    13.         <!-- 解释：  
    14.             多对一关系标签：  
    15.             <many-to-one name=“” class=“” column=“”/>  
    16.               
    17.             1、第1个问号：group是User类的属性，对应于name属性名  
    18.             2、第2个问号：class表达的是本对象(User)与Group的关系  
    19.             3、第3个问号：column是属性名+Id  
    20.             当我们写完注释之后，我们直接拷贝问号的对应关系即可。  
    21.          -->  
    22.     </class>  
    23. </hibernate-mapping>  

     Group.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.     </class>  
    12. </hibernate-mapping>  

    生成的表结构，与上面的分析的关系模型一样：
              

          项目中，多对一关联映射是最常见的映射，但它是Hibernate的关联映射中最简单的一种映射关系。

    （二）一对一单向关联映射

    映射原理

          两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。我们看一下这个例子的对象模型，如下图所示：

    对象模型

           

            从上图中可以看出：

            1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；

            2、人(Person)持有身份证(IdCard)的引用，所以，两个对象关系维护由person端决定。

            从对象模型映射成关系模型，有两种方式：主键关联和唯一外键关联，我们继续看下面的内容。

    分类： 

     主键关联：

            1、两个实体对象的主键一样，以表明它们之间的一一对应关系；

            2、不需要多余的外键字段来维护关系，仅通过主键来关联，即Person的主键要依赖IdCard的主键，他们共用一个主键值。

            以上两点恰与唯一外键关联相反。

     主键关联的关系模型

     Person.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Person" table="t_person">  
    7.         <id name="id">  
    8.         <!-- 采用foreign生成策略，forgeign会取得另外一个关联对象的标识 -->  
    9.             <generator class="foreign" >  
    10.                 <param name="property">idCard</param>  
    11.             </generator>  
    12.         </id>  
    13.         <property name="name"></property>  
    14.         <!--   
    15.             one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
    16.             也就是拿到关系字段值，根据对端的主键来加载关联对象  
    17.               
    18.             constrained="true"表示约束，当前主键（person的主键）还是一个外键  
    19.             参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
    20.          -->  
    21.          <!-- idCard属性，表达的是本对象与IdCard的一对一关系。 -->  
    22.         <one-to-one name="idCard" class="IdCard"  constrained="true"></one-to-one>  
    23.     </class>  
    24. </hibernate-mapping>  

    生成的表结构以及测试数据：

    唯一外键关联：

           1、两个实体对象用一个外键来关联，以表表明对象之间的关系。

           2、其实它是多对一关联映射的特例，多的一端加上唯一的限制之后，用来表示一对一的关联关系。

           所以它采用多对一的标签来映射，如下所示：

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. <!-- 采用<mang-to-one>标签来映射，指定多的一端unique为true,  
    2.     这样就限制了多的一端的多重性为一，就是这样来映射的。  
    3. -->  
    4. <many-to-one name="" unique="true"></many-to-one>  

    唯一外键的关系模型

    Person.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Person" table="t_person">  
    7.         <id name="id">  
    8.             <generator class="native" ></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- 由于它是一对一的唯一外键关联，它是多对一关联的特例，注释可以直接写成多对一关联-->  
    12.         <!-- idCard属性，表达的是本对象与IdCard的多对一关系。 -->  
    13.         <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>      
    14.     </class>  
    15. </hibernate-mapping>  

    生成的表结构以及测试数据：

     

    其他相同代码如下：

    Person

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. public class Person {  
    2.     private int id;  
    3.     private String name;  
    4.     private IdCard idCard;  
    5.       
    6.     public IdCard getIdCard() {  
    7.         return idCard;  
    8.     }  
    9.     public void setIdCard(IdCard idCard) {  
    10.         this.idCard = idCard;  
    11.     }  
    12.     public int getId() {  
    13.         return id;  
    14.     }  
    15.     public void setId(int id) {  
    16.         this.id = id;  
    17.     }  
    18.     public String getName() {  
    19.         return name;  
    20.     }  
    21.     public void setName(String name) {  
    22.         this.name = name;  
    23.     }  
    24. }  

    IdCard

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. public class IdCard {  
    2.     private int id;  
    3.     private String cardNo;  
    4.     public int getId() {  
    5.         return id;  
    6.     }  
    7.     public void setId(int id) {  
    8.         this.id = id;  
    9.     }  
    10.     public String getCardNo() {  
    11.         return cardNo;  
    12.     }  
    13.     public void setCardNo(String cardNo) {  
    14.         this.cardNo = cardNo;  
    15.     }  
    16. }  

    IdCard.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="IdCard" table="t_idCard">  
    7.         <id name="id">  
    8.             <generator class="native"></generator>  
    9.         </id>  
    10.         <property name="cardNo"></property>  
    11.     </class>  
    12. </hibernate-mapping>  

    建议

    由于一对一主键关联映射具有以下两个缺点：

          1、灵活性差，没有办法改成多对一关联映射，不能应变多变的需求；

          2、必须先保存关联对象IdCard，之后才能保持Person；

    所以，在映射一对一单向关联映射时，我们采用唯一外键关联映射。

    （三）一对一双向关联映射

     

    上面我们介绍了一对一的单向关联映射，单向是指只能从人（Person）这端加载身份证端（IdCard），但是反过来，不能从身份证端加载人得信息。如图所示：

          

          关键原因在于对象模型具有方向性：

    单向：一端只能加载另一端，不能反过来。

    双向：两端都可以加载另一端。

          问题来了：如何我们想从身份证端（IdCard）加载人（Person），怎么办呢？

          下面我们开始介绍一对一的双向关联映射。

     映射原理

           双向关联映射与单向关联映射的原理是一样的，双向关联映射并不影响存储，只影响加载。所以，双向关联映射和单向关联映射的关系模型是一样的即数据库的表结构是一样的，只是IdCard的实体类和配置文件（IdCard.hbm.xml）发生了一点点变化。

     对象模型

               

     从上图中可以看出：

            1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一对一的关系；

            2、两个对象得关系维护还是由person端决定（因为关系只能由一端维护主键，否则关系就乱了）。

           根据上面的对象模型，我们可以看到Person端没有变化，但是要在IdCard端加上Person的引用，例如Person和IdCard实体类如下。

    Person

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2.   
    3. public class Person {  
    4.     private int id;  
    5.     private String name;  
    6.     private IdCard idCard;  
    7.       
    8.     public IdCard getIdCard() {  
    9.         return idCard;  
    10.     }  
    11.     public void setIdCard(IdCard idCard) {  
    12.         this.idCard = idCard;  
    13.     }  
    14.     public int getId() {  
    15.         return id;  
    16.     }  
    17.     public void setId(int id) {  
    18.         this.id = id;  
    19.     }  
    20.     public String getName() {  
    21.         return name;  
    22.     }  
    23.     public void setName(String name) {  
    24.         this.name = name;  
    25.     }  
    26. }  

     IdCard

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2.   
    3. public class IdCard {  
    4.     private int id;  
    5.     private String cardNo;  
    6.     private Person person;  
    7.       
    8.     public Person getPerson() {  
    9.         return person;  
    10.     }  
    11.     public void setPerson(Person person) {  
    12.         this.person = person;  
    13.     }  
    14.     public int getId() {  
    15.         return id;  
    16.     }  
    17.   
    18.     public void setId(int id) {  
    19.         this.id = id;  
    20.     }  
    21.     public String getCardNo() {  
    22.         return cardNo;  
    23.     }  
    24.     public void setCardNo(String cardNo) {  
    25.         this.cardNo = cardNo;  
    26.     }  
    27. }  

         无论是单向关联映射还是双向关联映射，他们都属于一对一关联映射，只是他们主键的生成策略不同，分为主键关联映射和唯一外键关联映射。

         由于它们都属于一对一关联映射，所以，Hibernate封装双向关联映射时，主键关键映射和唯一外键关联映射的加载策略一样，都采用的是一对一<one-to-one name=""></one-to-one>，只是属性设置不一致，所以，下面我们分开来看IdCard的配置文件。

    分类：

    主键关联映射

         同一对一单向关联映射类似，主键关联即利用主键进行关联，关联主键的值相同。下面我们看一下映射文件：

    IdCard.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="IdCard" table="t_idCard">  
    7.         <id name="id">  
    8.             <generator class="native"></generator>  
    9.         </id>  
    10.         <property name="cardNo"></property>  
    11.         <!-- 怎么加载对象，抓取策略：join联合查询（默认），select:一条条的查询 -->  
    12.         <one-to-one name="person" class="Person" fetch="join"></one-to-one>  
    13.     </class>  
    14. </hibernate-mapping>  

    Person.hbm.xml，同一对一单向主键关联映射一样

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Person" table="t_person">  
    7.         <id name="id">  
    8.         <!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->  
    9.             <generator class="foreign" >  
    10.                 <param name="property">idCard</param>  
    11.             </generator>  
    12.         </id>  
    13.         <property name="name"></property>  
    14.         <!--   
    15.             one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
    16.             也就是拿到关系字段值，根据对端的主键来加载关联对象  
    17.               
    18.             constrained="true"表示，当前主键（person的主键）还是一个外键  
    19.             参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
    20.          -->  
    21.         <one-to-one name="idCard" class="IdCard" constrained="true"></one-to-one>  
    22.     </class>  
    23. </hibernate-mapping>  

    生成的表结构

     

    唯一外键关联映射

        

           一对一双向关联映射的外键关联映射也与一对一单向关联映射的外键关联映射类似，在其一对一的指向端(Person)存在一个唯一外键，该唯一外键与被指向端(IdCard)相关联，关联主键的值相同。下面我们看一下映射文件：
     

    IdCard.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="IdCard" table="t_idCard">  
    7.         <id name="id">  
    8.             <generator class="native"></generator>  
    9.         </id>  
    10.         <property name="cardNo"></property>  
    11.         <!-- 一对一唯一外键关联双向采用<one-to-one>标签来映射，必须指定<one-to-one>  
    12.             标签中的property-ref属性为关系字段的名称  
    13.          -->  
    14.         <one-to-one name="person" class="Person" property-ref="idCard"></one-to-one>  
    15.     </class>  
    16. </hibernate-mapping>  

    Person.hbm.xml，同一对一单向唯一外键关联映射一样

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Person" table="t_person">  
    7.         <id name="id">  
    8.             <generator class="native" ></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- 由于它是一对一的唯一外键关联，它是多对一关联的特例，注释可以直接写成多对一关联-->  
    12.         <!-- idCard属性，表达的是本对象与IdCard的多对一关系。 -->  
    13.         <many-to-one name="idCard" class="IdCard" column="idCardId" unique="true"></many-to-one>      
    14.     </class>  
    15. </hibernate-mapping>  

    生成的表结构

            

    对比

           一对一单向和双向关联映射的区别正是对象模型和关系模型的区别之一。

    对象模型：有方向性。它到底是单向还是双向是由对象模型决定的即配置文件决定。

    关系模型：没有方向性或者说是双向的。从任何一端都可以加载另一端。

    下载

             以上内容，只证明了一对一双向关联映射不影响存储即没有改变表结构，但不能证明关联是双向的，需要写相应的测试用例，我们以源码的形式给大家。源码下载

     总结

           一对一双向关联映射并不是必须的，是由需求下决定的。如果没有这样的需求，用户也没有要求，系统也不需要，就没有必要建立双向的关联映射。

    （四）一对多关联映射

    映射原理

          一对多关联映射和多对一关联映射的映射原理是一致的，都是在多的一端加入一个外键，指向一的一端。关联关系都是由多端维护，只是在写映射时发生了变化。

    多对一和一对多的区别

             多对一和一对多的区别在于维护的关系不同：

    （1）多对一：多端维护一端的关系，在加载多端时，可以将一端加载上来。

    （2）一对多：一端维护多端的关系，在加载一端时，可以将多端加载上来。

    分类

    一对多单向关联映射

    对象模型

              

          从对象模型中，我们可以看出，Group持有User的一个引用。由于是单向关联，所以数据在加载Group时，会把User加载上来，但是User并不知道Group的存在。

          我们先看一下Group和User的实体，以及映射文件。

    Group

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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. }  

    User

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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属性，只影响数据的存储，也就是持久化。

    目的

           一对多双向关联映射的目的主要是为了解决一对多单向关联的缺陷而不是需求驱动的。

    （五）多对多关联映射

    映射原理

         不论是单向关联还是双向关联都是通过第三张表，将两个表中的主键放到第三张做一个关联。用第三张表来解决可能会造成数据冗余的问题。

    举例

    一个用户（User）对多个角色（Role），一个角色对多个用户。

    分类

    单向的多对多关联映射（单向User--->Role）

    对象模型

                  

    关系模型

                

    实例

          下面我们看一下实体类和映射文件的代码。

    User

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2.   
    3. import java.util.Set;  
    4.   
    5. public class User {  
    6.     private int id;  
    7.     private String name;  
    8.       
    9.     private Set roles;  
    10.       
    11.     public int getId() {  
    12.         return id;  
    13.     }  
    14.     public void setId(int id) {  
    15.         this.id = id;  
    16.     }  
    17.     public Set getRoles() {  
    18.         return roles;  
    19.     }  
    20.     public void setRoles(Set roles) {  
    21.         this.roles = roles;  
    22.     }  
    23.     public String getName() {  
    24.         return name;  
    25.     }  
    26.     public void setName(String name) {  
    27.         this.name = name;  
    28.     }  
    29.       
    30. }  

    Role

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2.   
    3. public class Role {  
    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 plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- roles属性，表达的是本对象（User）与Role的多对多的关系 -->    
    12.         <set name="roles" table="t_user_role">  
    13.             <!--当前表（User）的主键-->  
    14.             <key column="user_id"></key>  
    15.             <many-to-many class="Role" column="role_id"></many-to-many>  
    16.         </set>  
    17.     </class>  
    18. </hibernate-mapping>  

    Role.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Role" table="t_role">  
    7.         <id name="id">  
    8.             <generator class="native"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.     </class>  
    12. </hibernate-mapping>  

    生成的表结构和测试数据

           多对多关联映射，在实体类中，跟一对多关联映射一样，也是用集合来表示的。<set>标签中用table属性重命名中间表名称，<key>标签定义当前表的主键，用<many-to-many>标签来关联另一张表。

    双向的多对多关联映射（双向User<--->Role）

    对象模型

                 

    关系模型

           同上

    实例

          

         下面我们看一下实体类和映射文件的代码。

    User

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2. import java.util.Set;  
    3.   
    4. public class User {  
    5.     private int id;  
    6.     private String name;  
    7.       
    8.     private Set roles;  
    9.       
    10.     public int getId() {  
    11.         return id;  
    12.     }  
    13.     public void setId(int id) {  
    14.         this.id = id;  
    15.     }  
    16.     public Set getRoles() {  
    17.         return roles;  
    18.     }  
    19.     public void setRoles(Set roles) {  
    20.         this.roles = roles;  
    21.     }  
    22.     public String getName() {  
    23.         return name;  
    24.     }  
    25.     public void setName(String name) {  
    26.         this.name = name;  
    27.     }  
    28.       
    29. }  

    Role

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. package com.liang.hibernate;  
    2. import java.util.Set;  
    3. public class Role {  
    4.     private int id;  
    5.     private String name;  
    6.     private Set users;  
    7.       
    8.     public Set getUsers() {  
    9.         return users;  
    10.     }  
    11.     public void setUsers(Set users) {  
    12.         this.users = users;  
    13.     }  
    14.     public int getId() {  
    15.         return id;  
    16.     }  
    17.     public void setId(int id) {  
    18.         this.id = id;  
    19.     }  
    20.     public String getName() {  
    21.         return name;  
    22.     }  
    23.     public void setName(String name) {  
    24.         this.name = name;  
    25.     }  
    26. }  

    User.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- roles属性，表达的是本对象(User)与Role的多对多的关系 -->    
    12.         <set name="roles" table="t_user_role">  
    13.             <!--当前表（User）的主键-->  
    14.             <key column="user_id"></key>  
    15.             <many-to-many class="Role" column="role_id"></many-to-many>  
    16.         </set>  
    17.     </class>  
    18. </hibernate-mapping>  

    Role.hbm.xml

    [html] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    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="Role" table="t_role">  
    7.         <id name="id">  
    8.             <generator class="native"></generator>  
    9.         </id>  
    10.         <property name="name"></property>  
    11.         <!-- users属性，表达的是本对象(Role)与User的多对多的关系 -->    
    12.         <set name="users" table="t_user_role">  
    13.             <!--当前表（Role）的主键-->                  
    14.             <key column="role_id"></key>  
    15.             <many-to-many class="User" column="user_id"></many-to-many>  
    16.         </set>  
    17.     </class>  
    18. </hibernate-mapping>  

    生成的表结构和测试数据

          多对多双向关系中，User和Role的映射文件相同，值得注意的是生成的中间表名称必须一样，生成中间表的字段必须一样。

    总结

          多对多关联映射到此就结束了，经过对一对多关联映射的学习，相对而言，多对多关联映射变得非常的简单了，非常像一对多关联映射的变体。

          Hibernate是一个对象关系映射框架，当然从分层的角度看，我们也说它是数据持久层的框架。

          我们从上一句话可以看出Hibernate的核心：面向对象、关系映射以及数据持久化。前面两个概念很容易理解，而对于“数据持久化”，就是将数据或者某物体，永久的保存起来。现实生活中的例子有很多，例如：鲜肉冷藏，水果做成罐头，而对于编程而言就是将数据保存在文件或磁盘以及数据库中。下面我们再看一下Hibernate的核心对象：

    核心对象

             

         上面这幅图反馈给我们的信息有很多，能否读懂这幅图可以从侧面反映你对Hibernate理解的水平。下面我们说几条：

    1、Hibernate有俩个主要的配置文件：（Hibernate.cfg.xml和xxx.hbm.xml）

    2、Hibernate有五个或六个接口：Configuration、SessionFactory、Session、Transaction、Query和Criteria。

    3、Hibernate的执行原理，看上图的箭头即可。

    4、Session对象是通过SessionFactory构建的，这是Hibernate创建Session的两种方式之一。

    。。。。。。

          由于内容太多，我们暂时就列这么多，就不再一一列举了。下面我们再详细的介绍映射的分类。

    分类

           

            

          在Hibernate系列的起初，我将关系映射分为了以上四种，现在来看关系映射其实就两种，甚至一种。

    1、从对象的加载方向上分为单向和双向两种。

          单向和双向只影响数据的加载，并不影响数据的存储。不论是一对一，一对多还是多对多，单向和双向生成的数据库表是一样，单向和双向的不同是由对象模型决定的。

    2、从对象的映射关系上分为一对多和多对一两种，它们又是从不同角度说的，所以也可以说是一种。

          一对一关联映射是多对一关联映射的特例，只是在“多”的一端加上唯一的限制之后，用来表示一对一的关联关系。

          多对多关联映射是一对多关联映射的特例，它们呢都是使用集合来表示多的关系，用<key>标签定义当前表的主键。

         当然它们既有联系也有区别，区别就不再一一列举了，系列博文中已经详细的介绍了各自的联系与区别。



          Hibernate是一个对象关系映射框架，当然从分层的角度看，我们也说它是数据持久层的框架。

          我们从上一句话可以看出Hibernate的核心：面向对象、关系映射以及数据持久化。前面两个概念很容易理解，而对于“数据持久化”，就是将数据或者某物体，永久的保存起来。现实生活中的例子有很多，例如：鲜肉冷藏，水果做成罐头，而对于编程而言就是将数据保存在文件或磁盘以及数据库中。下面我们再看一下Hibernate的核心对象：

    核心对象

             

         上面这幅图反馈给我们的信息有很多，能否读懂这幅图可以从侧面反映你对Hibernate理解的水平。下面我们说几条：

    1、Hibernate有俩个主要的配置文件：（Hibernate.cfg.xml和xxx.hbm.xml）

    2、Hibernate有五个或六个接口：Configuration、SessionFactory、Session、Transaction、Query和Criteria。

    3、Hibernate的执行原理，看上图的箭头即可。

    4、Session对象是通过SessionFactory构建的，这是Hibernate创建Session的两种方式之一。

    。。。。。。

          由于内容太多，我们暂时就列这么多，就不再一一列举了。下面我们再详细的介绍映射的分类。

    分类

           

            

          在Hibernate系列的起初，我将关系映射分为了以上四种，现在来看关系映射其实就两种，甚至一种。

    1、从对象的加载方向上分为单向和双向两种。

          单向和双向只影响数据的加载，并不影响数据的存储。不论是一对一，一对多还是多对多，单向和双向生成的数据库表是一样，单向和双向的不同是由对象模型决定的。

    2、从对象的映射关系上分为一对多和多对一两种，它们又是从不同角度说的，所以也可以说是一种。

          一对一关联映射是多对一关联映射的特例，只是在“多”的一端加上唯一的限制之后，用来表示一对一的关联关系。

          多对多关联映射是一对多关联映射的特例，它们呢都是使用集合来表示多的关系，用<key>标签定义当前表的主键。

         当然它们既有联系也有区别，区别就不再一一列举了，系列博文中已经详细的介绍了各自的联系与区别。
  • 相关阅读:
    【Python基础】13_Python中的PASS
    【Python基础】12_Python中的容器类型公共方法
    【Python基础】11_Python中的字符串
    【Python基础】10_Python中的字典
    【Python基础】09_Python中的元组
    【Python基础】08_Python中的列表
    【Python基础】07_Python中的模块
    Json2Html
    数字转换成美元和人民币
    单击行变色
  • 原文地址：https://www.cnblogs.com/mannixiang/p/6664966.html
Copyright © 2020-2023  润新知