hibernate映射-继承映射

对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。Hibernate的继承映射可以理解成持久化类之间的继承关系。例如：人和学生之间的关系。学生继承人，可以认为学生是一个特殊的人，如果对人进行查询，学生的实例也将被得到。

Hibernate支持3种继承映射策略：

①使用 subclass进行映射：

将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑域模型中的继承关系和多态。

②使用 joined-subclass进行映射：

对于继承关系中的子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。

③使用 union-subclass进行映射：

域模型中的每一个类映射到一个表，通过关系数据模型中的外键来描述表之间的继承关系。这也就相当于按照域模型的结构来建立数据库中的表，并通过外键来建立表之间的继承关系。

二、详解：

1. subclass元素的继承映射：

采用subclass的继承映射可以实现对于继承关系中的父类和子类使用同一张表，因为父类和子类的实例全部保存在同一个表中，因此需要在该表内增加一列，使用该列来区分每行记录到底是哪个类的实例---这个列被称为辨别者列（discriminator）

在这种映射策略下，使用 subclass 来映射子类，使用class或所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列并没有值，这将引起数据库的完整性约束，导致父类的实例无法保存到数据库中。

代码示例：

 1 package com.zit.hibernate.subclass;
 2  
 3 public class Person {
 4     
 5     private int id;
 6     private String name;
 7     private int age;
 8     
 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 int getAge() {
23         return age;
24     }
25     public void setAge(int age) {
26         this.age = age;
27     }
28     
29 }

 1 package com.zit.hibernate.subclass;
 2  
 3 public class Student extends Person{
 4     
 5     private String school;
 6  
 7     public String getSchool() {
 8         return school;
 9     }
10  
11     public void setSchool(String school) {
12         this.school = school;
13     }
14     
15 }

映射文件，只需要写父类

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.zit.hibernate.subclass">
    <class name="Person" table="PERSONS" discriminator-value="PERSON">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="native" />
        </id>
        
        <!-- 配置辨别者列 -->
        <discriminator column="TYPE" type="string"></discriminator>
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        
        <!-- 映射子类Student，使用subclass进行映射 -->
        <subclass name="Student" discriminator-value="STUDENT">
            <property name="school" type="string" column="SCHOOL">
            </property>
        
        </subclass>
    </class>
</hibernate-mapping>

注意：

① subclass的配置方式是将父子类的记录保存着同一个表中，用辨别者列来识别是父类还是子类的记录，所以配置中都需要配置discriminator-value

② 在保存数据时，辨别者列由Hibernate 自动维护，不需要手动操作。

例如：在保存记录： session.save(person); session.save(student);

生成的sql分别如下：

Hibernate: 
    insert 
    into
        PERSONS
        (NAME, AGE, TYPE) 
    values
        (?, ?, 'PERSON')
Hibernate: 
    insert 
    into
        PERSONS
        (NAME, AGE, SCHOOL, TYPE) 
    values
        (?, ?, ?, 'STUDENT')

③ 查询记录时，多态查询时，用父类来查询会查询出所有的记录

例如：List<Person> list = session.createQuery("FROM Person").list(); 这会查询出前面配置的PERSONS表中的所有的记录。

（测试时，“FROM PERSON” 中间的空格，之前手抖打成了全角的空格，hehe，导致测试报错：node to traverse cannot be null. 这个错误一般都是hql语句有问题，仔细点应该不会出现）

而查询子类记录时，则只会查询子类的记录，如下SQL语句可以看出Hibernate的查询方式：(中间打印的数字，是我输出了数据库中的记录数)

Hibernate: 
    select
        person0_.ID as ID1_0_,
        person0_.NAME as NAME3_0_,
        person0_.AGE as AGE4_0_,
        person0_.SCHOOL as SCHOOL5_0_,
        person0_.TYPE as TYPE2_0_ 
    from
        PERSONS person0_
6
Hibernate: 
    select
        student0_.ID as ID1_0_,
        student0_.NAME as NAME3_0_,
        student0_.AGE as AGE4_0_,
        student0_.SCHOOL as SCHOOL5_0_ 
    from
        PERSONS student0_ 
    where
        student0_.TYPE='STUDENT'
3

查询父类，子类记录都只需要查询一张表

缺点：

① 增加了辨别者列

② 子类独有的字段不能添加非空约束（如果某个子类的某个属性的值不能为空，那么在数据库一级是不能设置该字段为NOT NULL的。）

③ 若继承层次较深，则数据表的字段会比较多

2. 使用 joined-subclass 元素的继承映射

采用 joined-subclass 元素的继承映射可以实现每个子类一张表。采用这种映射策略时，父类实例保存在父类表中，子类实例由父类表和子类表共同存储。因为子类实例也是一个特殊的父类实例，因此必然也包含了父类实例的属性。于是将子类和父类共有的属性保存在父类表中，子类增加的属性，则保存在子类表中。这种映射策略下，无须使用鉴别者列，但需要为每个子类使用 key 元素映射共有主键。子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中。

代码示例：

类文件同上，仅对包名做了更改。

映射文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.zit.hibernate.joined.subclass">
    <class name="Person" table="PERSONS" discriminator-value="PERSON">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="native" />
        </id>
        
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        
        
        <joined-subclass name="Student" table="STUDENTS">
            <key column="STUDENT_ID"></key>
            <property name="school" type="string" column="SCHOOL"></property>
        </joined-subclass>
        
        
        <!-- 映射子类Student，使用subclass进行映射 -->
    </class>
</hibernate-mapping>
注意：

注意：

① 保存记录时，Person的存储只会有一条 insert，而Student的存储会有两条 insert，因为子类的存储涉及到两张表。

例：

Hibernate: 
    insert 
    into
        PERSONS
        (NAME, AGE) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        PERSONS
        (NAME, AGE) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        STUDENTS
        (SCHOOL, STUDENT_ID) 
    values
        (?, ?)

② 查询记录时，同样有多态查询。但是查询时都会用到内连接查询两个表内的记录，查询效率较低。

优点：

① 不需要使用辨别者列

② 子类独有的字段能添加非空约束

③ 没有冗余字段（父类的字段在父表中，子类独有的字段在字表中）

3. 使用 union-subclass 元素的继承映射

采用 union-subclass 元素可以实现将每一个实体对象映射到一个独立的表中。子类增加的属性可以有非空约束 --- 即父类实例的数据保存在父表中，而子类实例的数据保存在子类表中。子类实例的数据仅保存在子类表中, 而在父类表中没有任何记录。在这种映射策略下，子类表的字段会比父类表的映射字段要多,因为子类表的字段等于父类表的字段、加子类增加属性的总和。

在这种映射策略下，既不需要使用鉴别者列，也无须使用 key 元素来映射共有主键。使用 union-subclass 映射策略是不可使用 identity 的主键生成策略, 因为同一类继承层次中所有实体类都需要使用同一个主键种子, 即多个持久化实体对应的记录的主键应该是连续的. 受此影响, 也不该使用 native 主键生成策略, 因为 native 会根据数据库来选择使用 identity 或 sequence.

映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.zit.hibernate.union.subclass">
    <class name="Person" table="PERSONS">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="hilo" />
        </id>
        
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        
        <union-subclass name="Student" table="STUDENTS">
            <property name="school" column="SCHOOL" type="string"></property>
        </union-subclass>
        
    </class>
</hibernate-mapping>

注意：

① 主键的生成策略不能使 identity 或 sequence。

② 查询时，查询父类记录较慢，要用到子查询，

缺点：

① 存在冗余字段

② 更新父表效率较低

hibernate映射-继承映射

猜你喜欢