Hibernate - 继承关联关系映射

简介: 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缺点:

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



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


9.png

目录
相关文章
|
9月前
|
SQL XML 存储
Hibernate框架【五】——基本映射——多对多映射
Hibernate框架【五】——基本映射——多对多映射
120 0
|
Java 数据库连接
mybatis-plus和hibernate 忽略映射字段
mybatis-plus和hibernate 忽略映射字段
246 1
|
SQL Java 数据库连接
《Hibernate上课笔记》-----class3----Hibernate的单实体映射
《Hibernate上课笔记》-----class3----Hibernate的单实体映射
94 0
|
XML Java 数据库连接
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
65 0
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
|
存储 SQL Java
hibernate学习笔记之二(映射关系与懒加载)
hibernate学习笔记之二(映射关系与懒加载)
hibernate学习笔记之二(映射关系与懒加载)
|
SQL 存储 数据可视化
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
153 0
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
|
Oracle 关系型数据库 Java
hibernate注解 映射序列到Oracle
hibernate注解 映射序列到Oracle
|
XML Java 数据库连接
2021-5-13讲课内容hibernate主键id映射_XML方式
概述 项目结构 Student类 hibernate.cfg.xml log4j.properties Student.hbm.xml StudentTest类 理论 常用的五种方式 1. increment: 2. identity主键自增 3.sequence 序列 4. native 5. uuid
199 0
2021-5-13讲课内容hibernate主键id映射_XML方式
|
存储 Java 数据库连接
【SSH快速进阶】——Hibernate继承映射:每个具体类映射一张表
  上篇文章说的是每个类映射一张表,不管是父类还是子类。与上篇文章不同的是,这里是每个“具体类”映射一张表,什么意思呢?就是让每个子类(具体的、有意义的类)映射一张表。
【SSH快速进阶】——Hibernate继承映射:每个具体类映射一张表
|
存储 Java 数据库连接
【SSH快速进阶】——Hibernate继承映射:每个类映射一张表
上文说了每棵继承树映射一张表,本文继续描述让每个类都映射一张表的配置。
【SSH快速进阶】——Hibernate继承映射:每个类映射一张表