hibernate映射-继承映射
对于面向对象的程序设计语言而言,继承和多态是两个最基本的概念。Hibernate的继承映射可以理解成持久化类之间的继承关系。例如:人和学生之间的关系。学生继承人,可以认为学生是一个特殊的人,如果对人进行查询,学生的实例也将被得到。
Hibernate支持3种继承映射策略:
①使用 subclass进行映射:
将域模型中的每一个实体对象映射到一个独立的表中,也就是说不用在关系数据模型中考虑域模型中的继承关系和多态。
②使用 joined-subclass进行映射:
对于继承关系中的子类使用同一个表,这就需要在数据库表中增加额外的区分子类类型的字段。
③使用 union-subclass进行映射:
域模型中的每一个类映射到一个表,通过关系数据模型中的外键来描述表之间的继承关系。这也就相当于按照域模型的结构来建立数据库中的 表,并通过外键来建立表之间的继承关系。
二、详解:
1. subclass元素的继承映射:
采用subclass的继承映射可以实现对于继承关系中的父类和子类使用同一张表,因为父类和子类的实例全部保存在同一个表中,因此需要在该表内增加一列,使用该列来区分每行记录到底是哪个类的实例---这个列被称为辨别者列(discriminator)
在这种映射策略下,使用 subclass 来映射子类,使用class或所有子类定义的字段都不能有非空约束。如果为那些字段添加非空约束,那么父类的实例在那些列并没有值,这将引起数据库的完整性约束,导致父类的实例无法保存到数据库中。
代码示例:
Person.class
package com.zit.hibernate.subclass;
public class Person {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int 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;
}
}
Student.class (继承自Person)
package com.zit.hibernate.subclass;
public class Student extends Person{
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}
映射文件
Person.hbm.xml(只需要写父类)
<?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 元素映射共有主键。子类增加的属性可以添加非空约束。因为子类的属性和父类的属性没有保存在同一个表中。
代码示例:
类文件同上,仅对包名做了更改。
映射文件:
Person.hbm.xml
<?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 元素的继承映射
映射文件
<?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。
② 查询时,查询父类记录较慢,要用到 子查询,
缺点:
① 存在冗余字段
② 更新父表效率较低