Hibernate核心思想—ORM机制

最新推荐文章于 2023-12-18 20:06:48 发布

pengpegV5yaya

最新推荐文章于 2023-12-18 20:06:48 发布

阅读量1.3k

点赞数

分类专栏： hibernate 文章标签： ORM机制

hibernate 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

hibernate是一个采用ORM（Object/Relation Mapping对象关系映射）机制持久层的开源框架

其主要核心思想是面向对象，而非面向过程，而这个面向对象则主要通过ORM实现。

ORM是将表与表之间的操作，映射成对象和对象之间的操作，就是通过操作实体类来达到操作表的目的。从数据库提取的数据会自动按你设置的映射要求封装成特定的对象。之后你就可以通过对对象进行操作来修改数据库中的数据。这时候你面对的不是信息的碎片，而是一个形象鲜明的对象。

最简单的情况下，hibernate把数据表的数据段映射到类的属性上，那么这个数据表的定义本身就对应于一个类的定义，而每一个数据行将映射成该类的一个对象。

所以hibernate就是通过将数据表和实体类之间的映射，使得对对象的修改对应数据行的修改，不用考虑关系型的数据库表，使得程序思考角度完全对象化，更符合面向对象思维，同时也简化了持久层的代码，使逻辑结构更清晰。

下面来全面了解Hibernate的核心---对象关系映射机制。

热身运动：

</id>

</class>

实体类----表，采用<class>标签

实体类中的普通属性（不包括集合、自定义类和数组）-----表字段，采用<property>标签映射

注意：如果实体类的名称或实体类中属性的名称和数据库关键字重复，将会出现问题

可以考虑采用table属性和column属性对其进行重新命名

实体类的设计原则：

* 实现无参的默认的构造函数

* 提供一个标识

* 建议不要使用final修饰实体类

* 建议为实体类生成getter和setter方法

基础的映射不再介绍，重点是配置实体类之间的关系，正式进入实体类关系映射

这次主要介绍实体类之间的一对一映射

（一）单向一对一主键映射

说明：主键关联：即让两个对象具有相同的主键值，以表明他们之间的一一对应关系，数据库表不会有额外的字段来维护他们之间的关系，仅通过表的主键来关联。

例如人和身份证之间意义对应。Person-IdCard

在这个例子中，Person的主键参考IdCard的主键生成，其实就是IdCard的主键。所以IdCard的主键id既是主键，也是外键。

实体类的写法很简单，属性和get，set方法，空构造函数，按照上面提到的原则和UML图写就可以。

主要来介绍映射文件的写法：

Person.hbm.xml

[html]view plaincopy 
    
 <?xml version="1.0"?>  
   
 <!DOCTYPE hibernate-mapping PUBLIC   
   
       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class name="com.bjpowernode.hibernate.Person" table="t_person">  
              <id name="id"><!--主键的写法-->  
                     <!-- 采用foreign生成策略，forgeign会取得关联对象的标识 -->  
                     <generator class="foreign">  
                            <!-- property只关联对象 -->  
                            <param name="property">idCard</param>  
                     </generator>  
              </id>  
              <property name="name"/><!--普通属性的写法-->               
              <one-to-one name="idCard" constrained="true"/>  
       </class>  
  </hibernate-mapping>  

通过One-to-one标签来确定了Person和IdCard的关系，

one-to-one指示hibernate如何加载其关联对象，<param>标签表明了要关联的对象，默认根据主键加载。也就是拿到关系字段值，根据对端的主键来加载关联对象

这个关系确定了Person类对象可以通过idCard的get和set方法来得到和设置其对应的IdCard对象。

constrained="true表示，当前主键(person的主键)还是一个外键参照了对端的主键（IdCard的主键），也就是会生成外键约束语句。

部分示例代码：

[java]view plaincopy 
    
 session = HibernateUtils.getSession();  
 session.beginTransaction();                      
 IdCard idCard = new IdCard();  
 idCard.setCardNo("1");                 
 Person person = new Person();  
 person.setName("张三");  
 //建立关联  
    person.setIdCard(idCard);  
 session.save(person);  
 person.getCardNo();//取得关联对象  

IdCard.hbm.xml

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC   
       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">  
              <id name="id">  
                     <generator class="native"/>//主键生成策略采用native  
              </id>  
              <property name="cardNo"/>  
       </class>  
 </hibernate-mapping>  

因为Person和idCard的关系由Person来维护，即有Person断可以持有IdCard对象，而idCard并不知道Person的存在，所以IdCard的映射文件就是其本身映射，没有其他标签。

（二）双向一对一主键映射

因为Person和IdCard是一对一关系，如果IdCard也想得到与之对应的Person对象，那就可以将他们之间的关系设置成双向的。

此时IdCard的实体类需要加入person属性，用来装载其对应的Person对象。

Person类的映射文件不变，IdCard映射文件需要加入<one-to-one>标签，指示hibernate将关联对象Person根据主键加载上来。

IdCard.hbm.xml

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC   
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
        <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">  
               <id name="id">  
                      <generator class="native"/>  
               </id>  
               <property name="cardNo"/>  
               <one-to-one name="person"/>  
        </class>  
 </hibernate-mapping>  
   
   
    

因为<one-to-one>不影响存储，只影响加载，所以单向关联和双向关联所生成的数据库的表机构不变。

此时对象双方都可以互相加载对方，都持有对方的引用。

（三）单向一对一唯一外键映射

因为采用主键关联的扩展性不好，主键直接生成，修改之后对双方都有很大影响，基本没有办法进行修改。所以比较好的是采用唯一外键关联。

一对一唯一外键关联映射其实是多对一的特例。多对一的关联将在下篇文章中介绍。

实体类与单向一对一主键映射中一样。

主要改变的是Person类的映射。

Person.hbm.xml

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC   
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
      <class name="com.bjpowernode.hibernate.Person" table="t_person">  
             <id name="id">  
                    <generator class="native"/>  
             </id>  
             <property name="name"/>  
             <many-to-one name="idCard" unique="true"/>  
      </class>  
 </hibernate-mapping>  

IdCard.hbm.xml,不持有关系，如下

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC   
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
      <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">  
             <id name="id">  
                    <generator class="native"/>  
             </id>  
             <property name="cardNo"/>  
      </class>  
 </hibernate-mapping>  

采用<many-to-one>标签来映射，指定多的一端unique为true，这样就限制了多的一端的多重性。

唯一，就是这样来映射的。

通过<many-to-one>的映射，会在数据库表中生成一个idCard字段，通过idCard字段关联IdCard表类维持Person与IdCard的关系

生成的表如下：

（四）双向一对一唯一外键映射

如果想在IdCard里同时持有与之对应的Person对象，则需要要实体类idCard里加入person字段，实体类与双向一对一主键映射相同。

映射文件的写法Person.hbm.xml与单向一对一唯一外键映射相同，

不同的是IdCard.hbm.xml,如下：

[html]view plaincopy 
    
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC   
       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class name="com.bjpowernode.hibernate.IdCard" table="t_idCard">  
              <id name="id">  
                     <generator class="native"/>  
              </id>  
              <property name="cardNo"/>  
              <one-to-one name="person" property-ref="idCard"/>  
       </class>  
 </hibernate-mapping>  

一对一唯一外键关联双向采用<one-to-one>标签映射，必须指定<one-to-one>

标签中的property-ref属性为关系字段的名称，因为不是idCard不是主键，所以在此必须指定。

此关系生成的数据库表与单向一对一唯一外键相同，因为双向用到的是,<one-to-one>标签，此标签只影响加载，不影响数据库表结构。

关于这四个关系映射，对比记忆理解之后特别简单清楚，主要是两个标签<one-to-one>,和<many-to-one>。Hibernate的思想就是在配置文件中通过标签的位置，便可以直接生成数据库表，而且对象之间的关系也明确了，可以根据配置进行相应对象的加载，不再需要面向关系数据库，不用写级联查询语句，而是直接操作对象就可以。绝对的面向对象编程。

（五）单向一对多映射

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

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

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

Classes.java

[java]view plaincopy 
   
 public class Classes {   
       private intid;  
       privateString name;  
       private Setstudents;  
    //省略属性的get和set方法…….  
 }  

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

Classes.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class  name="com.wh.hibernate.Classes"table="t_classes">  
              <id  name="id">  
                     <generator  class="native"/>  
              </id>  
              <property  name="name"/>  
              <set  name="students">  
                     <key  column="classesid"/>  
                     <one-to-many  class="com.wh.hibernate.Student"/>  
              </set>   
       </class>  
 </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 plaincopy 
   
 public class Student {  
       private intid;      
       privateString name;       
       privateClasses classes;  
    //…………….省略属性的get和set方法  
 ｝  

Student.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class  name="com.wh.hibernate.Student"table="t_student">  
              <id  name="id">  
                     <generator  class="native"/>  
              </id>  
              <property  name="name"/>  
              <many-to-one  name="classes"  column="classesid"/>  
       </class>  
 </hibernate-mapping>  

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

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

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

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

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
       "-//Hibernate/HibernateMapping DTD 3.0//EN"  
       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
       <class  name="com.wh.hibernate.Classes"table="t_classes">  
              <id  name="id">  
                     <generator  class="native"/>  
              </id>  
              <property  name="name"/>  
              <set  name="students"  inverse="true">  
                     <!-- 
                     在set标签上加上了inverse=true标签，表示classes一端不在维护关系，交给Student维护 
                      -->  
                     <key  column="classesid" />  
                     <one-to-many  class="com.wh.hibernate.Student" />  
              </set>  
       </class>  
 </hibernate-mapping>  

（七）单向多对多映射

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

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

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

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

Role.java

[java]view plaincopy 
   
 public class Role {  
    private int id;  
 private Stringname;  
 //……省略set和get方法  
 ｝  

User.java

[java]view plaincopy 
   
 public class User {  
        privateint id;    
        privateString name;    
        privateSet roles;  
 //……省略set和get方法  
 }  

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

Role.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
        <class  name="com.wh.hibernate.Role" table="t_role">  
               <id  name="id">  
                      <generator  class="native"/>  
               </id>  
               <property  name="name"/>           
        </class>   
 </hibernate-mapping>  

User.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
        <class  name="com.wh.hibernate.User" table="t_user">  
               <id  name="id">  
                      <generator  class="native"/>  
               </id>  
               <property  name="name"/>  
               <set  name="roles" table="t_user_role">  
 <!—表示set内容生成了一个新的t_user_role表-->  
                   <key column="user_id"/>  
 <!--t_user_role表中的主键为user_id-->  
                   <many-to-many  class="com.wh.hibernate.Role"   column="role_id"/>  
 <!--t_user_role表中的另外一个字段为role_id，并有many-to-many的class标签得知role_id来自Role实体类中的主键-->  
               </set>  
        </class>  
 </hibernate-mapping>  

（八）双向多对多映射

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

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

[java]view plaincopy 
   
 Role.java  
 public class Role {  
    private int id;  
 private Stringname;  
 private Set users;  
 //……省略set和get方法  
 ｝  

Role.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping>  
        <class  name="com.wh.hibernate.Role" table="t_role">  
               <id  name="id">  
                      <generator  class="native"/>  
               </id>  
               <property  name="name"/>  
               <set  name="users" table="t_user_role">  
                   <key column="role_id"/>  
                   <many-to-many   class="com.wh.hibernate.User"   column="user_id"/>        
               </set>  
        </class>  
 </hibernate-mapping>  

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

总结：

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

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

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

（八）继承映射（1）单表继承，每棵继承树使用一个表

这种方法是一个继承的树总共生成一张表，因为类继承树肯定是对应多个类，所以如果要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段。

用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：

1、父类用普通的<class>标签定义在父类中定义一个discriminator，即指定这个区分的字段的名称和类型。

如：<discriminatorcolumn=”XXX” type=”string”/>

2、子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：

Subclass标签的name属性是子类的全路径名

在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值Subclass标签，既可以被class标签所包含（这种包含关系，表明了类之间的继承关系），也可以与class标签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。

3、子类的其它属性，像普通类一样，定义在subclass标签的内部。

举例：

Type就是鉴别值，P表示为猪，B表示为鸟。

Animal.java

[java]view plaincopy 
   
 public class Animal {  
      private int id;    
      private String name;    
      private boolean sex;  
   //………省略get和set方法  
 ｝  

Pig.java

[java]view plaincopy 
   
 public class Pig extends Animal {  
      private int weight;  
 //………省略get和set方法  
 }  

Brid.java

[java]view plaincopy 
   
 public class Bird extends Animal {  
      private int height;  
 //………省略get和set方法  
 }  

Animal.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
      "-//Hibernate/HibernateMapping DTD 3.0//EN"  
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping package="com.wh.hibernate">  
      <class  name="Animal"table="t_animal" lazy="false">  
             <id  name="id">  
                    <generator class="native"/>  
             </id>  
 <!--规定在表中新加的鉴别字段为名为type，类型是string，会在数据库中自动转换成数据库支持的字符类型。-->  
             <discriminator  column="type"type="string"/>  
 <!--两个普通属性-->  
             <property  name="name"/>  
             <property  name="sex"/>  
 <!--定义子类对象，并描述对应的鉴别值-->  
             <subclass  name="Pig" discriminator-value="P">  
 <!--属于这个子类的特殊属性-->  
                     
 <property  name="weight"/>  
             </subclass>  
             <subclass  name="Bird"discriminator-value="B">  
                    <property  name="height"/>  
             </subclass>  
      </class>  
 </hibernate-mapping>  

关于鉴别值在存储的时候hibernate会自动存储，不用手动赋值，在加载的时候会根据鉴别值取得相关的对象。

需要注意的一点是，鉴别字段的定义必须放到Id的后面。

（九）继承映射（2）具体表继承，每个子类一个表

这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。

在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。

实现这种策略的时候，有如下步骤：

1、父类用普通的<class>标签定义即可，父类不再需要定义discriminator字段

2、子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：

Joined-subclass标签的name属性是子类的全路径名

Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。

如：<keycolumn=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。

Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

3、子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

举例：

还是上面的例子，用第一种方法生成一个表，用第二种方法就是生成的三个表。

实体类的写法与（八）中的相同。重点看映射文件。

Animal.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping package="com.wh.hibernate">  
        <class  name="Animal" table="t_animal">  
               <id name="id">  
                      <generator class="native"/>  
               </id>  
 <!--两个普通属性-->  
               <property  name="name"/>  
               <property  name="sex"/>  
 <!--使用Joined-subclass标签，说明这个类是class的子类，生成一个单独的表t_pig-->  
               <joined-subclass  name="Pig"table="t_pig">  
 <!--就是主表中的id，自动关联-->  
                      <key column="pid"/>  
 <!--子类的普通属性-->  
                      <property  name="weight"/>  
               </joined-subclass>  
               <joined-subclass  name="Bird" table="t_bird">  
                      <key  column="bid"/>  
                      <property  name="height"/>  
               </joined-subclass>  
        </class>  
 </hibernate-mapping>  

（十）继承映射（3）类表继承，每个具体类一个表

这种继承策略是把父类当作一个抽象类，不生成父类表，把每个继承父类的子类生成一张表。每个子表中都有父类的属性。

使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段，这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段。实现这种策略的时候，有如下步骤：

1、父类用普通<class>标签定义即可

2、子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：

Union-subclass标签不再需要包含key标签（与joined-subclass不同）

Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

3、子类的其它属性，像普通类一样，定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。

举例，还是上面的例子，实体类都相同，重点是映射文件。

Animal.hbm.xml

[html]view plaincopy 
   
 <?xml version="1.0"?>  
 <!DOCTYPE hibernate-mapping PUBLIC  
        "-//Hibernate/HibernateMapping DTD 3.0//EN"  
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
 <hibernate-mapping package="com.wh.hibernate">  
 <!--将Animal的类型设置为true，表明不生成实体表-->  
        <class  name="Animal"  abstract="true">  
               <id  name="id">  
 <!--注意ID的生成策略，不能是native-->  
                      <generator class="assigned"/>  
               </id>  
      <!--两个普通属性-->  
               <property  name="name"/>  
               <property  name="sex"/>  
      <!--表明继承关系，集成了父类的属性，表名为t_pig-->  
               <union-subclass  name="Pig"  table="t_pig">  
                      <property  name="weight"/>  
               </union-subclass>  
               <union-subclass  name="Bird"table="t_bird">  
                      <property  name="height"/>  
               </union-subclass>  
        </class>  
 </hibernate-mapping>  