AI 助理
备案控制台
开发者社区 数据库 文章 正文

Hibernate - 继承关联关系映射

2023-12-13 71
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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

文章标签：
Java
数据库连接
数据库
SQL
存储
关键词：
Hibernate映射
Hibernate关系映射
Hibernate继承
流烟默
目录
相关文章
土木林森
|
2月前
|
Java 数据库连接 API
解锁高效开发秘籍：深入探究 Hibernate 如何优雅处理一对多与多对多关系，让数据映射再无烦恼！
【9月更文挑战第3天】Hibernate 是 Java 领域中最流行的 ORM 框架之一，广泛用于处理实体对象与数据库表之间的映射。尤其在处理复杂关系如一对多和多对多时，Hibernate 提供了丰富的 API 和配置选项。本文通过具体代码示例，展示如何使用 `@OneToMany`、`@JoinColumn`、`@ManyToMany` 和 `@JoinTable` 等注解优雅地实现这些关系，帮助开发者保持代码简洁的同时确保数据一致性。
土木林森
52 4
土木林森
|
3月前
|
Java 数据库连接 数据库
AI 时代风起云涌，Hibernate 实体映射引领数据库高效之路，最佳实践与陷阱全解析！
【8月更文挑战第31天】Hibernate 是一款强大的 Java 持久化框架，可将 Java 对象映射到关系数据库表中。本文通过代码示例详细介绍了 Hibernate 实体映射的最佳实践，包括合理使用关联映射（如 `@OneToMany` 和 `@ManyToOne`）以及正确处理继承关系（如单表继承）。此外，还探讨了常见陷阱，例如循环依赖可能导致的无限递归问题，并提供了使用 `@JsonIgnore` 等注解来避免此类问题的方法。通过遵循这些最佳实践，可以显著提升开发效率和数据库操作性能。
土木林森
84 0
土木林森
|
3月前
|
数据库 开发者 Java
Hibernate映射注解的魔力：实体类配置的革命，让你的代码量瞬间蒸发！
【8月更文挑战第31天】Hibernate 是一款出色的对象关系映射框架，简化了 Java 应用与数据库的交互。其映射注解让实体类配置变得直观简洁。本文深入剖析核心概念与使用技巧，通过示例展示如何简化配置。
土木林森
45 0
王卫
|
SQL XML 存储
Hibernate框架【五】——基本映射——多对多映射
Hibernate框架【五】——基本映射——多对多映射
王卫
191 0
流烟默
|
6月前
|
SQL Java 关系型数据库
Hibernate - 对象关系映射文件(*.hbm.xml)详解
Hibernate - 对象关系映射文件(*.hbm.xml)详解
流烟默
266 1
众所周知
|
6月前
|
缓存 Java 数据库连接
Hibernate或MyBatis：ORM映射、缓存机制等知识讲解梳理
Hibernate或MyBatis：ORM映射、缓存机制等知识讲解梳理
众所周知
129 0
流烟默
|
6月前
|
Java 数据库连接 数据库
Hibernate5中实体映射命名策略
Hibernate5中实体映射命名策略
流烟默
134 0
流烟默
|
6月前
|
机器学习/深度学习 SQL Java
Hibernate - 多对多关联关系映射
Hibernate - 多对多关联关系映射
流烟默
60 0
流烟默
|
6月前
|
SQL Java 数据库连接
Hibernate -双向一对一关联关系映射
Hibernate -双向一对一关联关系映射
流烟默
55 0
流烟默
|
6月前
|
SQL XML Java
Hibernate - 单向多对一关联关系映射
Hibernate - 单向多对一关联关系映射
流烟默
39 0

热门文章

最新文章

  • 1
    简单的Hibernate入门简介
  • 2
    Hibernate缓存和ehcache
  • 3
    hibernate注解方式的二级缓存
  • 4
    Hibernate JPA简介
  • 5
    【Hibernate框架开发之五】Hibernate对象的三种状态&Session常用方法
  • 6
    Hibernate之查询中get()和load()的区别，list()和iterate()的区别
  • 7
    一口一口吃掉Hibernate（三）——Hibernate给表和字段设置前后缀及分隔符
  • 8
    Use xDoclet For Hibernate
  • 9
    Hibernate-01-配置
  • 10
    struts2+hibernate+spring分页实现(DAO,Service,Action三层架构搭配)
  • 1
    Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
    78
  • 2
    如何在Spring Boot中集成Hibernate
    118
  • 3
    使用Hibernate实现复杂数据库查询优化策略
    48
  • 4
    使用Hibernate实现复杂数据库查询优化策略
    59
  • 5
    必知的技术知识：HHS整合（Struts2+Spring+Hibernate）
    38
  • 6
    技术经验分享：Hibernate之HQL
    31
  • 7
    程序技术好文：电脑睡眠（sleep）和休眠（Hibernate）的区别，以及休眠功能的设置
    143
  • 8
    技术好文共享：电脑睡眠（sleep）和休眠（Hibernate）的区别，以及休眠功能的设置
    95
  • 9
    深入理解Java中的JPA与Hibernate
    57
  • 10
    从理论到实践：Hibernate与JPA在Java项目中的实际应用
    47

    • 相关电子书

    更多
  • 继承与功能组合
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-1：对象类型
    • 下一篇
    阿里云OSS设置跨域访问