对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。Hibernate 的继承映射可以理解持久化类之间的继承关系。例如：人和学生之间的关系。学生继承了人，可以认为学生是一个特殊的人，如果对人进行查询，学生的实例也将被得到。
Hibernate支持三种继承映射策略：
- 使用 subclass 进行映射： 对于继承关系中的父类子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。
- 使用 joined-subclass 进行映射： 将域模型中的每一个子类分别映射到一个独立的表中，通过关系数据模型中的外键来描述表之间的继承关系。这也就相当于按照域模型的结构来建立数据库中的表，并通过外键来建立表之间的继承关系。
- 使用 union-subclass 进行映射：域模型中的每个类分别单独映射到一个单独表，关系数据模型不用考虑域模型中的继承关系和多态。
【1】采用 subclass 元素的继承映射
采用 subclass 的继承映射可以实现对于继承关系中父类和所有子类使用同一张表。
因为父类和子类的实例全部保存在同一个表中，因此需要在该表内增加一列，使用该列来区分每行记录到底是哪个类的实例----这个列被称为辨别者列(discriminator)。
在这种映射策略下，使用 subclass 来映射子类，使用 class 或 subclass 的 discriminator-value 属性指定辨别者列的值。
所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束，那么父类的实例在那些列其实并没有值，这将引起数据库完整性冲突，导致父类的实例无法保存到数据库中。
① Person类如下：
public class Person {
private Integer id;
private String name;
private int age;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}② Student类如下
public class Student extends Person{
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
@Override
public String toString() {
return "Student [school=" + school + ", toString()=" + super.toString() + "]";
}
}③ Person.hbm.xml如下：
<hibernate-mapping package="com.jane.subclass">
<class name="Person" table="PERSONS" discriminator-value="PERSON">
<id name="id" type="java.lang.Integer">
<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>
④ 持久化测试
对于子类对象只需把记录插入到一张数据表中，辨别者列由 Hibernate 自动维护。
代码如下：
@Test
public void testSave(){
Person person = new Person();
person.setAge(11);
person.setName("AA");
session.save(person);
Student stu = new Student();
stu.setAge(22);
stu.setName("BB");
stu.setSchool("JANE");
session.save(stu);
}
测试结果如下：
Hibernate:
create table PERSONS (
ID integer not null auto_increment,
TYPE varchar(255) not null,
NAME varchar(255),
AGE integer,
SCHOOL varchar(255),
primary key (ID)
) engine=InnoDB
Hibernate:
insert
into
PERSONS
(NAME, AGE, TYPE)
values
(?, ?, 'PERSON')
Hibernate:
insert
into
PERSONS
(NAME, AGE, SCHOOL, TYPE)
values
(?, ?, ?, 'STUDENT')
⑤ 查询操作
代码如下：
@Test
public void testQuery(){
List<Person> persons = session.createQuery("FROM Person").list();
System.out.println(persons.size());
List<Student> stus = session.createQuery("FROM Student").list();
System.out.println(stus.size());
}
测试结果如下：
Hibernate:
select
person0_.ID as ID1_8_,
person0_.NAME as NAME3_8_,
person0_.AGE as AGE4_8_,
person0_.SCHOOL as SCHOOL5_8_,
person0_.TYPE as TYPE2_8_
from
PERSONS person0_
2
Hibernate:
select
student0_.ID as ID1_8_,
student0_.NAME as NAME3_8_,
student0_.AGE as AGE4_8_,
student0_.SCHOOL as SCHOOL5_8_
from
PERSONS student0_
where
student0_.TYPE='STUDENT'
1
查询父类时，将所有属性都查询出来，查询SQL中不需要where条件。查询子类时，只查询子类继承父类属性和子类自有属性，并且查询SQL使用了where条件。
不过相同的是，查询父类或者子类只需要查询同一张表。
SubClass缺点 :
- 使用了辨别者列。
- 子类独有的字段不能添加非空约束。
- 若继承层次较深, 则数据表的字段也会较多。
【2】采用 joined-subclass 元素的继承映射
采用 joined-subclass 元素的继承映射可以实现每个子类对应一张表。
采用这种映射策略时，父类实例保存在父类表中，子类实例由父类表和子类表共同存储。
因为子类实例也是一个特殊的父类实例，因此必然也包含了父类实例的属性。于是将子类和父类共有的属性保存在父类表中，子类增加的属性，则保存在子类表中。
在这种映射策略下，无须使用鉴别者列，但需要为每个子类使用 key 元素映射共有主键。
子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中。
① 修改Person.hbm.xml如下：
<hibernate-mapping package="com.jane.joined.subclass">
<class name="Person" table="PERSONS">
<id name="id" type="java.lang.Integer">
<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>
</class>
</hibernate-mapping>
② 持久化测试
代码如下：
@Test
public void testSave(){
Person person = new Person();
person.setAge(11);
person.setName("AA");
session.save(person);
Student stu = new Student();
stu.setAge(22);
stu.setName("BB");
stu.setSchool("JANE");
session.save(stu);
}
测试结果如下：
Hibernate:
create table PERSONS (
ID integer not null auto_increment,
NAME varchar(255),
AGE integer,
primary key (ID)
) engine=InnoDB
Hibernate:
create table STUDENTS (
STUDENT_id integer not null,
SCHOOL varchar(255),
primary key (STUDENT_id)
) engine=InnoDB
Hibernate:
alter table STUDENTS
add constraint FK1v1p0142kff4r512ncp4prcy5
foreign key (STUDENT_id)
references PERSONS (ID)
Hibernate:
insert
into
PERSONS
(NAME, AGE)
values
(?, ?)
Hibernate:
insert
into
PERSONS
(NAME, AGE)
values
(?, ?)
Hibernate:
insert
into
STUDENTS
(SCHOOL, STUDENT_id)
values
(?, ?)
可以看到，插入父类是直接插入了persons表；插入子类的时候则插入了两张表中，将继承父类的属性插入到父表中，子类私有属性插入到子类表中。且子类表中的Student_id与父类表中的主键有外键约束关系。
③ 查询获取操作
代码如下：
@Test
public void testQuery(){
List<Person> persons = session.createQuery("FROM Person").list();
System.out.println(persons.size());
List<Student> stus = session.createQuery("FROM Student").list();
System.out.println(stus.size());
}
测试结果如下：
Hibernate:
select
person0_.ID as ID1_0_,
person0_.NAME as NAME2_0_,
person0_.AGE as AGE3_0_,
person0_1_.SCHOOL as SCHOOL2_1_,
case
when person0_1_.STUDENT_id is not null then 1
when person0_.ID is not null then 0
end as clazz_
from
PERSONS person0_
left outer join
STUDENTS person0_1_
on person0_.ID=person0_1_.STUDENT_id//左外连接查询
2
Hibernate:
select
student0_.STUDENT_id as ID1_0_,
student0_1_.NAME as NAME2_0_,
student0_1_.AGE as AGE3_0_,
student0_.SCHOOL as SCHOOL2_1_
from
STUDENTS student0_
inner join
PERSONS student0_1_
on student0_.STUDENT_id=student0_1_.ID//内连接查询
1
Person表查询语句执行结果如下：
查询父类记录, 使用一个左外连接查询； 对于子类记录, 使用一个内连接查询。
joined-subclass优点是：
- 不需要使用了辨别者列.
- 子类独有的字段能添加非空约束.
- 没有冗余的字段.
【3】采用 union-subclass 元素的继承映射
采用 union-subclass 元素可以实现将每一个实体对象分别映射到一个独立的表中。
子类增加的属性可以有非空约束 — 即父类实例的数据保存在父表中，而子类实例的数据保存在子类表中。
子类实例的数据仅保存在子类表中, 而在父类表中没有任何记录。
在这种映射策略下，子类表的字段会比父类表的映射字段要多,因为子类表的字段等于父类表的字段、加子类增加属性的总和。
在这种映射策略下，既不需要使用鉴别者列，也无须使用 key 元素来映射共有主键。
使用 union-subclass 映射策略时不可使用 identity 的主键生成策略, 因为同一类继承层次中所有实体类都需要使用同一个主键种子, 即多个持久化实体对应的记录的主键应该是连续的。受此影响, 也不该使用 native 主键生成策略, 因为 native 会根据数据库来选择使用 identity 或 sequence。
① 修改Person.hbm.xml如下：
<hibernate-mapping package="com.jane.union.subclass">
<class name="Person" table="PERSONS">
<id name="id" type="java.lang.Integer">
<column name="ID" />
<generator class="increment" />
</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>
② 持久化测试
代码如下：
@Test
public void testSave(){
Person person = new Person();
person.setAge(11);
person.setName("AA");
session.save(person);
Student stu = new Student();
stu.setAge(22);
stu.setName("BB");
stu.setSchool("JANE");
session.save(stu);
}
测试结果如下：
Hibernate:
select
max(ids_.mx)
from
( select
max(ID) as mx
from
STUDENTS
union
select
max(ID) as mx
from
PERSONS
) ids_
Hibernate:
insert
into
PERSONS
(NAME, AGE, ID)
values
(?, ?, ?)
Hibernate:
insert
into
STUDENTS
(NAME, AGE, SCHOOL, ID)
values
(?, ?, ?, ?)
可以看到父类和子类各自插入了一张表中，子类属性包含父类属性，子类和父类直接没有外键关系。
③ 查询对象测试
代码如下：
@Test
public void testQuery(){
List<Person> persons = session.createQuery("FROM Person").list();
System.out.println(persons.size());
List<Student> stus = session.createQuery("FROM Student").list();
System.out.println(stus.size());
}
测试结果如下：
Hibernate:
select
person0_.ID as ID1_0_,
person0_.NAME as NAME2_0_,
person0_.AGE as AGE3_0_,
person0_.SCHOOL as SCHOOL1_1_,
person0_.clazz_ as clazz_
from
( select
ID,
NAME,
AGE,
null as SCHOOL,
0 as clazz_
from
PERSONS
union
select
ID,
NAME,
AGE,
SCHOOL,
1 as clazz_
from
STUDENTS
) person0_
2
Hibernate:
select
student0_.ID as ID1_0_,
student0_.NAME as NAME2_0_,
student0_.AGE as AGE3_0_,
student0_.SCHOOL as SCHOOL1_1_
from
STUDENTS student0_
1
可以看到，查询父类记录, 需把父表和子表记录汇总到一起再做查询–如上所示做了子查询union。查询子类记录则只需要从一张表中简单查询即可。
④ 更新对象测试
代码如下：
@Test
public void testUpdate(){
String hql = "UPDATE Person p SET p.age = 20";
session.createQuery(hql).executeUpdate();
}
测试结果如下：
Hibernate:
create temporary table if not exists HT_PERSONS (ID integer not null)
Hibernate:
insert
into
HT_PERSONS
select
person0_.ID as ID
from
( select
ID,
NAME,
AGE,
null as SCHOOL,
0 as clazz_
from
PERSONS
union
select
ID,
NAME,
AGE,
SCHOOL,
1 as clazz_
from
STUDENTS
) person0_
Hibernate:
update
PERSONS
set
AGE=20
where
(
ID
) IN (
select
ID
from
HT_PERSONS
)
Hibernate:
update
PERSONS
set
AGE=20
where
(
ID
) IN (
select
ID
from
HT_PERSONS
)
Hibernate:
update
STUDENTS
set
AGE=20
where
(
ID
) IN (
select
ID
from
HT_PERSONS
)
Hibernate:
drop temporary table HT_PERSONS
更新是相当麻烦。
union-subclass优点：
- 无需使用辨别者列.
- 子类独有的字段能添加非空约束.
union-subclass缺点：
- 存在冗余的字段
- 若更新父表的字段, 则更新的效率较低。
【4】三种继承映射方式分析比较
比较方面 | union-subclass | subclass | joined-subclass |
建立关系模型的原则 | 每个具体类对应一张表 | 父类和子类共用一张表 | 父类单独一张表，每个子类一张表，子类表不包含父类属性列 ；子类和父类有外键关联关系 |
关系模型的优缺点 | 表中存在重复字段 | 表中引入了区分子类的字段；不能为子类属性设置非空约束 | 符合关系模型设计原则，且无字段重复 |
可维护性 | 如果需要对基类进行修改，则需要对基类及其子类所对应的所有表都进行修改 | 只需要修改一张表，很方便 | 维护比较方便，对每个类的修改只需要修改其所对应的表 |
灵活性 | 映射的灵活性很大，子类可以对包括基类属性在内的每一个属性进行单独的配置 | 灵活性差，表中的冗余字段会随着子类的增多而增多 | 灵活性很好，完全是参照对象继承的方式进行映射配置 |
查询的性能 | 对于子类的查询只需要访问单独的表；但对父类的查询需要访问所有表 | 在任何情况下的查询都需要处理这一张表 | 对于父类的查询需要使用左外连接；而子类查询则需要使用内连接 |
维护的性能 | 对于单个对象的持久化操作只需要处理一个表 | 对于单个对象的持久化操作只需要处理一个表 | 对于子类的持久化操作至少需要处理两个表；对于父类的持久化操作只需要处理一个表 |
