Hibernate核心思想—ORM机制（二）

上篇文章总结了对象之间的一对一映射。而在关系模型中，最常见的映射为一对多和多对多。

一对一映射主要用到的标签<one-to-one>,一对多主要用到<many-to-one>和<one-to-many>，多对多用到<many-to-many>.下面一一来看。

（五）单向一对多映射

        一对多映射情况非常多件，今天以班级和学生举例，一个班级对应多个学生，一个学生对应一个班级，从而形成一对多关系。如图：

 

        一对多关系由一的一方来维护，在这个例子里由classes来维护，通过在配置文件中加入set标签，这个用来存放student表中的记录。One-to-many标签指定存放的内容

        因为classes对象要持有多个student对象，所以在classes实体类中需要有个属性Set容器来存放student对象。

Classes.java

[java] view plain copy

1. public class Classes {   
2.       private intid;  
3.       privateString name;  
4.       private Setstudents;  
5.    //省略属性的get和set方法…….  
6. }  

        Classes类的配置文件中对Set属性的陪住需要使用专门的set标签，,<key column=”classesid”>是映射到多的一端表student中的列名，然后需要用到<one-to-many>标签，在这个标签里说明了set属性中存放的是student类的对象。

Classes.hbm.xml

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.       <class  name="com.wh.hibernate.Classes"table="t_classes">  
7.              <id  name="id">  
8.                     <generator  class="native"/>  
9.              </id>  
10.              <property  name="name"/>  
11.              <set  name="students">  
12.                     <key  column="classesid"/>  
13.                     <one-to-many  class="com.wh.hibernate.Student"/>  
14.              </set>   
15.       </class>  
16. </hibernate-mapping>  

      由于student类不进行关系维护，所以student类的配置正常配属性就可以。

 

一对一关系映射的关系由一的一端维护，而在一的一端维护关系存在以下缺陷：

       1、因为多的一端Student不知道Classes的存在（也就是Student没有维护与Classes的关系）

             所以在保存Student的时候关系字段classesid是为null的，如果将该关系字段设置为非空，则 将无法保存数据

       2、另外因为Student不维护关系，而Classes维护关系，Classes就会发出多余的update语句，保证       Classes和Student有关系，这样加载Classes的时候才可以把该Classes对应的学生加载上来

  由于一的一端维护关系的效率并不高，所以这种映射方法不提倡使用。一般来说这种关系有要配置成双向的，继续来看。

     （六）双向一对多映射

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

        一对多的双向映射在（五）的基础上，需要在student的一端加一个classes属性，来存放student所属的classes信息。在student的配置信息中需要对classes属性配置<many-to-one>标签，这个标签中的列名需要与classes中<key>标签规定的列名保持一致，才能使双方加载正确，否则会产生数据混乱。

       其中classes的实体类与（五）相同，不在赘述。

Student.java

[java] view plain copy

1. public class Student {  
2.       private intid;      
3.       privateString name;       
4.       privateClasses classes;  
5.    //…………….省略属性的get和set方法  
6. ｝  

Student.hbm.xml

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.       <class  name="com.wh.hibernate.Student"table="t_student">  
7.              <id  name="id">  
8.                     <generator  class="native"/>  
9.              </id>  
10.              <property  name="name"/>  
11.              <many-to-one  name="classes"  column="classesid"/>  
12.       </class>  
13. </hibernate-mapping>  

下面介绍一个重要的属性inverse：

        inverse属性可以用在一对多和多对多双向关联上，inverse属性默认为false，为false表示本端可以维护关系，如果inverse为true，则本端不能维护关系，会交给另一端维护关系，本端失效。

所以一对多关联映射我们通常在多的一端维护关系，让一的一端失效，所以设置为inverse为true。

       所以改良后的classes.hbm.xml:

 

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.       <class  name="com.wh.hibernate.Classes"table="t_classes">  
7.              <id  name="id">  
8.                     <generator  class="native"/>  
9.              </id>  
10.              <property  name="name"/>  
11.              <set  name="students"  inverse="true">  
12.                     <!-- 
13.                     在set标签上加上了inverse=true标签，表示classes一端不在维护关系，交给Student维护 
14.                      -->  
15.                     <key  column="classesid" />  
16.                     <one-to-many  class="com.wh.hibernate.Student" />  
17.              </set>  
18.       </class>  
19. </hibernate-mapping>  

 

（七）单向多对多映射

        一般的设计中，多对多关联映射，需要一个中间表，hibernate会自动生成中间表hibernate使用<many-to-many>标签来表示多对多的关联。

       多对多的关联映射，在实体类中，跟一对多一样，也是用set集合来表示。

       多对多采用用户和角色的例子来说明，一个用户可以有多个角色，一个角色也可以包含多个用户。如下图：

 

       单向映射由User来维护关系，所以User实体类中需要有Set集合属性来存放Role的值。

Role.java

[java] view plain copy

1. public class Role {  
2.    private int id;  
3. private Stringname;  
4. //……省略set和get方法  
5. ｝  

User.java

[java] view plain copy

1. public class User {  
2.        privateint id;    
3.        privateString name;    
4.        privateSet roles;  
5. //……省略set和get方法  
6. }  

 

因为User维护关系，所以Role的映射写法就是简单的映射

Role.hbm.xml

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.        <class  name="com.wh.hibernate.Role" table="t_role">  
7.               <id  name="id">  
8.                      <generator  class="native"/>  
9.               </id>  
10.               <property  name="name"/>           
11.        </class>   
12. </hibernate-mapping>  

 

User.hbm.xml

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.        <class  name="com.wh.hibernate.User" table="t_user">  
7.               <id  name="id">  
8.                      <generator  class="native"/>  
9.               </id>  
10.               <property  name="name"/>  
11.               <set  name="roles" table="t_user_role">  
12. <!—表示set内容生成了一个新的t_user_role表-->  
13.                   <key column="user_id"/>  
14. <!--t_user_role表中的主键为user_id-->  
15.                   <many-to-many  class="com.wh.hibernate.Role"   column="role_id"/>  
16. <!--t_user_role表中的另外一个字段为role_id，并有many-to-many的class标签得知role_id来自Role实体类中的主键-->  
17.               </set>  
18.        </class>  
19. </hibernate-mapping>  

（八）双向多对多映射

        双向映射就要在Role的一端持有User对象，那么在Role的实体类中就需要加上Set集合属性。并在配置文件中加入<many-to-many>标签配置。

User实体类和User的映射文件与（七）相同。

[java] view plain copy

1. Role.java  
2. public class Role {  
3.    private int id;  
4. private Stringname;  
5. private Set users;  
6. //……省略set和get方法  
7. ｝  

 

Role.hbm.xml

 

[html] view plain copy

1. <?xml version="1.0"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC  
3.        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
4.        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping>  
6.        <class  name="com.wh.hibernate.Role" table="t_role">  
7.               <id  name="id">  
8.                      <generator  class="native"/>  
9.               </id>  
10.               <property  name="name"/>  
11.               <set  name="users" table="t_user_role">  
12.                   <key column="role_id"/>  
13.                   <many-to-many   class="com.wh.hibernate.User"   column="user_id"/>        
14.               </set>  
15.        </class>  
16. </hibernate-mapping>  

 

        Role的配置与User相同，都是用到<many-to-many>标签，需要注意的是，User和Role映射出来的第三方表是同一张，所以名称需要相同，生成的中间表中的字段必须一样，否则加载出错。

 

总结：

        一对多映射中用到一的一端用到<one-to-many>标签，多的一端用到<many-to-one>标签。实体类持有多个对象的属性应使用Set集合属性，对应的配置中同样使用<set>标签。

        此外由于一对多映射由一方控制有缺陷，所以采用双向映射，并通过Inverse属性控制反转，使一端不维护关系。

        多对多映射使用<many-to-many>标签，需要指定第三个表。如果是双向映射，必须保证多对多双方映射的第三方表名称相同，字段相同。