hibernate映射-继承映射

（学习记录，错误不足之处，请您耐心指正^_^）

hibernate映射-继承映射

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

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

①使用 subclass进行映射：

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

②使用 joined-subclass进行映射：

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

③使用 union-subclass进行映射：

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

二、详解：

1. subclass元素的继承映射：

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

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

代码示例：

{类文件↓}

Person.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 }

Person.class

Student.class (继承自Person)

 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 }

Student.class

{映射文件}

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.zit.hibernate.subclass">
 6     <class name="Person" table="PERSONS" discriminator-value="PERSON">
 7         <id name="id" type="int">
 8             <column name="ID" />
 9             <generator class="native" />
10         </id>
11         
12         <!-- 配置辨别者列 -->
13         <discriminator column="TYPE" type="string"></discriminator>
14         
15         <property name="name" type="java.lang.String">
16             <column name="NAME" />
17         </property>
18         <property name="age" type="int">
19             <column name="AGE" />
20         </property>
21         
22         
23         <!-- 映射子类Student，使用subclass进行映射 -->
24         <subclass name="Student" discriminator-value="STUDENT">
25             <property name="school" type="string" column="SCHOOL">
26             </property>
27         
28         </subclass>
29     </class>
30 </hibernate-mapping>

Person.hbm.xml

注意：

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

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

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

生成的sql分别如下：

 1 Hibernate: 
 2     insert 
 3     into
 4         PERSONS
 5         (NAME, AGE, TYPE) 
 6     values
 7         (?, ?, 'PERSON')
 8 Hibernate: 
 9     insert 
10     into
11         PERSONS
12         (NAME, AGE, SCHOOL, TYPE) 
13     values
14         (?, ?, ?, 'STUDENT')

sql

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

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

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

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

 1 Hibernate: 
 2     select
 3         person0_.ID as ID1_0_,
 4         person0_.NAME as NAME3_0_,
 5         person0_.AGE as AGE4_0_,
 6         person0_.SCHOOL as SCHOOL5_0_,
 7         person0_.TYPE as TYPE2_0_ 
 8     from
 9         PERSONS person0_
10 6
11 Hibernate: 
12     select
13         student0_.ID as ID1_0_,
14         student0_.NAME as NAME3_0_,
15         student0_.AGE as AGE4_0_,
16         student0_.SCHOOL as SCHOOL5_0_ 
17     from
18         PERSONS student0_ 
19     where
20         student0_.TYPE='STUDENT'
21 3

sql

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

缺点：

① 增加了辨别者列

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

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

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

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

代码示例：

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

映射文件：

Person.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.zit.hibernate.joined.subclass">
 6     <class name="Person" table="PERSONS" discriminator-value="PERSON">
 7         <id name="id" type="int">
 8             <column name="ID" />
 9             <generator class="native" />
10         </id>
11         
12         
13         <property name="name" type="java.lang.String">
14             <column name="NAME" />
15         </property>
16         <property name="age" type="int">
17             <column name="AGE" />
18         </property>
19         
20         
21         
22         <joined-subclass name="Student" table="STUDENTS">
23             <key column="STUDENT_ID"></key>
24             <property name="school" type="string" column="SCHOOL"></property>
25         </joined-subclass>
26         
27         
28         <!-- 映射子类Student，使用subclass进行映射 -->
29     </class>
30 </hibernate-mapping>

Person.hbm.xml

注意：

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

例：

 1 Hibernate: 
 2     insert 
 3     into
 4         PERSONS
 5         (NAME, AGE) 
 6     values
 7         (?, ?)
 8 Hibernate: 
 9     insert 
10     into
11         PERSONS
12         (NAME, AGE) 
13     values
14         (?, ?)
15 Hibernate: 
16     insert 
17     into
18         STUDENTS
19         (SCHOOL, STUDENT_ID) 
20     values
21         (?, ?)

sql

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

优点：

① 不需要使用辨别者列

② 子类独有的字段不需要添加非空约束

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

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

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

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

映射文件

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2015-12-26 13:39:33 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.zit.hibernate.union.subclass">
 6     <class name="Person" table="PERSONS">
 7         <id name="id" type="int">
 8             <column name="ID" />
 9             <generator class="hilo" />
10         </id>
11         
12         
13         <property name="name" type="java.lang.String">
14             <column name="NAME" />
15         </property>
16         <property name="age" type="int">
17             <column name="AGE" />
18         </property>
19         
20         
21         <union-subclass name="Student" table="STUDENTS">
22             <property name="school" column="SCHOOL" type="string"></property>
23         </union-subclass>
24         
25     </class>
26 </hibernate-mapping>

Person.hbm.xml

注意：

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

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

缺点：

① 存在冗余字段

② 更新父表效率较低

（学习记录，错误不足之处，请您耐心指正^_^）

posted @ 2015-12-26 16:23 zhouzz 阅读(341) 评论(0) 编辑收藏举报

刷新页面返回顶部

zhouzz

hibernate映射-继承映射

公告