Hibernate - 继承关联关系映射-阿里云开发者社区

对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。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缺点：

存在冗余的字段
若更新父表的字段, 则更新的效率较低。

Hibernate - 继承关联关系映射

【1】采用 subclass 元素的继承映射

【2】采用 joined-subclass 元素的继承映射

【3】采用 union-subclass 元素的继承映射

【4】三种继承映射方式分析比较

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Hibernate - 继承关联关系映射

【1】采用 subclass 元素的继承映射

【2】采用 joined-subclass 元素的继承映射

【3】采用 union-subclass 元素的继承映射

【4】三种继承映射方式分析比较

热门文章

最新文章

相关电子书

相关实验场景