8.0 hibernate_映射继承关系

喜欢ヅ旅行 2022-06-01 04:19 193阅读 0赞

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">
    
    <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>
            
            
            
            <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">
    
    <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>
            
            
            
        </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">
    
    <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。

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

缺点：

① 存在冗余字段

② 更新父表效率较低

转载于：http://www.cnblogs.com/zitt/p/5077742.html