Hibernate的继承映射(十四)

原创

两个蝴蝶飞 2022-11-10 15:02:21 博主文章分类：Hibernate ©著作权

文章标签 Hibernate单表继承 Hibernate类表继承 hibernate 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者两个蝴蝶飞的原创作品，请联系作者获取转载授权，否则将追究法律责任

上一章简单介绍了Hibernate与Java的数据类型转换和对数组，集合的扩充(十三),如果没有看过,
以下所有的图片均来自于音①晓前辈。

一.Hibernate的继承映射

在实际项目中，常常会遇到有关继承的问题。如，图书馆项目中对普通学生和教师之间的处理。学生和教师拥有着很多相同的字段，如姓名，年龄，性别，生日等，也有着不同的字段，如学生有学号，教师的教师编号。普通的做法是为学生单独创建一个类，生成一个学生的表，为教师创建一个类，生成一个教师的表。然而，这样单独生成的话，学生和教师是完全分开的，而他们均有借书，还书，扣款等操作，需要在代码中进行区分教师和学生。学生借书就要new Student(), 教师借书就要new Teacher(), 无法实现对象多态。还有一种做法是，将学生和教师当成一个类，把他们所有的属性都放置在一个表里面，其中存在一个类型的字段type 来区分学生和教师。如type=1 表示学生, type=2 表示教师。在代码中，可以利用传递的type的不同，来进行不同的操作。

if(type==1){
  //执行学生的操作
}else if (type==2){
  //执行教师的操作
}

这样的设计也是不合理的。 1，需要在表中将学生和教师的所有的字段给包括起来。 2，教师和学生的区分是通过type来区分的，即type=1 时是学生，那么就要手动控制教师的特有属性为null,type=2时是教师，那么需要手动控制学生的特有属性为null. 3,最可怕的一点，不具有可扩展性。如果再加一个类型，如图书馆馆员。那么就要设置type=3, 并且将图书馆员的特有属性放置到这个表里面，即需要改变一下表的结构，多添加几个属性。这是非常危险的。所以，在Hibernate中提供了一种继承映射，来解决这些。将这种继承放置到Hibernate中，通过Hibernate来进行处理。
有三种方案:

一个子类对应一张表
使用一张表，表示所有继承体系下类的属性的并集
每一个子类使用一张表，记录它的独特属性，与父类所对应的表以一对一的方式关联起来。

二.第一种方案继承映射

来源于:音①晓前辈

Hibernate的继承映射(十四)_Hibernate类表继承

二.一父类Person

package com.yjl.pojo;
/**
@Date: 2019年3月24日
@author: 两个蝴蝶飞
@Description:父类 人员
*/
public class Person {
  /**
  注意，此时id是字符串形式。
   * @param id 主键
   * @param name 姓名
   * @param sex 性别
   * @param age 年龄
   */
  private String id;
  private String name;
  private String sex;
  private Integer age;
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getSex() {
    return sex;
  }
  public void setSex(String sex) {
    this.sex = sex;
  }
  public Integer getAge() {
    return age;
  }
  public void setAge(Integer age) {
    this.age = age;
  }
}

二.二子类Student

package com.yjl.pojo;
/**
@Date: 2019年3月24日
@author: 两个蝴蝶飞
@Description:学生的子类
*/
public class Student extends Person{
  /**
   * @param 学生独特的属性  编号
   */
  private String stuNo;

  public String getStuNo() {
    return stuNo;
  }
  public void setStuNo(String stuNo) {
    this.stuNo = stuNo;
  }
}

二.三子类Teacher

package com.yjl.pojo;
/**
@Date: 2019年3月24日
@author: 两个蝴蝶飞
@Description:教师的子类
*/
public class Teacher extends Person{
  /**
   * @param 老师的独特属性 salary 工资 
   */
  private Float salary;

  public Float getSalary() {
    return salary;
  }
  public void setSalary(Float salary) {
    this.salary = salary;
  }
}

二.四父类.hbm.xml 即Person.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入相应的约束 -->
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
  <!-- 这有一个abstract 如果为true,表示抽象，是不会生成Person表的。
  如果不写，或者为false,默认为false, 那么会生成Person表，但是并不会往里面插入数据。 建议写true -->
  <class name="com.yjl.pojo.Person" abstract="true">
    <id name="id" column="id" type="string">
      <!--注意，此时id是uuid 属性，并不是native-->
      <generator class="uuid"></generator>
    </id>
    <property name="name" column="name"></property>
    <property name="sex" column="sex"></property>
    <property name="age" column="age"></property>
  </class>
  <!-- 采用union-subclass来表明父子关系  name表示引用的类,table表示要生成的表,
  extends表示继承哪个父类-->
  <union-subclass name="com.yjl.pojo.Student" table="student"
  extends="com.yjl.pojo.Person">
    <!-- 学生的独特属性 -->
    <property name="stuNo" column="stuNo"></property>
    <!-- 如果有其他的独特属性，可以用property 继续往下写.-->
  </union-subclass>
  <!-- 继续依次写其他的子类 -->
  <union-subclass name="com.yjl.pojo.Teacher" table="teacher"
  extends="com.yjl.pojo.Person">
    <!-- 教师的独特属性 -->
    <property name="salary" column="salary"></property>
  </union-subclass>
</hibernate-mapping>

也可以将union-subclass写在class标签里面，明确表示是person类的子类，这样，就可以不用extends标签了。

<!-- 这有一个abstract 如果为true,表示抽象，是不会生成Person表的。
  如果不写，或者为false,默认为false, 那么会生成Person表，但是并不会往里面插入数据。 建议写true -->
  <class name="com.yjl.pojo.Person" abstract="true">
    <id name="id" column="id" type="string">
      <!--注意，此时id是uuid 属性，并不是native-->
      <generator class="uuid"></generator>
    </id>
    <property name="name" column="name"></property>
    <property name="sex" column="sex"></property>
    <property name="age" column="age"></property>
    <!-- 采用union-subclass来表明父子关系  name表示引用的类,table表示要生成的表,
  extends表示继承哪个父类-->
    <union-subclass name="com.yjl.pojo.Student" table="student">
      <!-- 学生的独特属性 -->
          <property name="stuNo" column="stuNo"></property>
      <!-- 如果有其他的独特属性，可以用property 继续往下写.-->
    </union-subclass>
  <!-- 继续依次写其他的子类 -->
    <union-subclass name="com.yjl.pojo.Teacher" table="teacher">
      <!-- 教师的独特属性 -->
          <property name="salary" column="salary"></property>
    </union-subclass>
  </class>

三种方式，均可以写在里面，或者写在外面。写在外面，就要用extends 来指定是哪一个父类。

二.五创建表 (代码与下面的方式一样)

@Test
  public void createTest(){
    Session session=HibernateUtil.getSession();
    session.close();
  }

Hibernate的继承映射(十四)_Hibernate类表继承_02

二.五插入数据 (代码与下面的方式一样)

@Test
  public void saveTest(){
    Session session=HibernateUtil.getSession();
    Transaction transaction=session.beginTransaction();
    // 用学生子类，不用父类。 
    Student student=new Student();
    student.setName("两个蝴蝶飞");
    student.setSex("男");
    student.setAge(24);
    student.setStuNo("1403070234");
    
    Teacher teacher =new Teacher();
    teacher.setName("精灵妹");
    teacher.setAge(24);
    teacher.setSex("女");
    teacher.setSalary(5000f);
    
    session.save(student);
    session.save(teacher);
    transaction.commit();
    session.close();
  }

Hibernate的继承映射(十四)_Hibernate单表继承_03

Hibernate的继承映射(十四)_Hibernate类表继承_04

Hibernate的继承映射(十四)_Hibernate类表继承_05

注意观察id,这就是为什么id生成策略不能是native的原因。如果是native,那么id在插入学生表是1,插入教师表是1 再次插入学生表是2，再次插入教师表是2，这样取出时是不能区分的。并不会在不同的表里面自动增长的。

二.六读取数据 (代码与下面的方式一样,只是将编号转换成普通的数字)

@Test
  public void readTest(){
    Session session=HibernateUtil.getSession();
    Transaction transaction=session.beginTransaction();
    // 查询学生
    Person student=session.get(Student.class,"8a81819169add45d0169add45f680000");
    readPerson(student);
    Person teacher=session.get(Teacher.class,"8a81819169add45d0169add45f8b0001");
    readPerson(teacher);
    transaction.commit();
    session.close();
  }
  private void readPerson(Person p){
    System.out.println(p.getName()+":"+p.getSex());
  }

Hibernate的继承映射(十四)_hibernate_06

这样就可以利用多态的方式进行操作了。其中,如果想到读取Student的学号和Teacher的工资，可以利用向下转型来取得。第二种方式时介绍，这里不做介绍了。

三. 第二种继承映射

Hibernate的继承映射(十四)_hibernate_07

这种映射是放在同一张表里面。所以，父类中的id可以用Integer形式。这里将父类用Integer来表示。子类的代码不变.

private Integer id;

配置文件: Person.hbm.xml

<hibernate-mapping>
  <!--这里不用写abstract="true" 写入一个table标签-->
  <class name="com.yjl.pojo.Person" table="person">
    <id name="id" column="id">
      <!--可以用自动增长-->
      <generator class="native"></generator>
    </id>
      <!-- 定义一个区别的属性  这个区别属性是嵌入到数据库中的。这个属性必须放在普通的属性最前面。-->
    <discriminator column="personType" type="string" ></discriminator>
    <property name="name" column="name"></property>
    <property name="sex" column="sex"></property>
    <property name="age" column="age"></property>
    <!-- 用的是subclass -->
    <subclass name="com.yjl.pojo.Student" discriminator-value="student">
      <!-- 学生的独特属性 -->
      <property name="stuNo" column="stuNo"></property>
      <!-- 如果有其他的独特属性，可以用property 继续往下写.-->
    </subclass>
    <!-- 继续依次写其他的子类 -->
    <subclass name="com.yjl.pojo.Teacher" discriminator-value="teacher">
      <!-- 教师的独特属性 -->
      <property name="salary" column="salary"></property>
    </subclass>
  </class>
</hibernate-mapping>

创建测试与第一种方式一样,运行之后是:

Hibernate的继承映射(十四)_Hibernate单表继承_08

插入的代码与第一种一样。不用我们手动维护这个personType的值。 Hibernate会自动插入的。

Hibernate的继承映射(十四)_Hibernate类表继承_09

没有的属性，会被设置成null.

Hibernate的继承映射(十四)_Hibernate单表继承_10

读取时:

@Test
  public void readTest(){
    Session session=HibernateUtil.getSession();
    Transaction transaction=session.beginTransaction();
    // 查询学生
    Person student=session.get(Student.class,1);
    readPerson(student);
    Person teacher=session.get(Teacher.class,2);
    readPerson(teacher);
    transaction.commit();
    session.close();
  }
  private void readPerson(Person p){
    System.out.println(p.getName()+":"+p.getSex());
    if(p instanceof Student){
      Student student=(Student)p;
      System.out.println(student.getStuNo());
    }else if (p instanceof Teacher){
      Teacher teacher =(Teacher) p;
      System.out.println(teacher.getSalary());
    }else{
      System.out.println("null");
    }
  }

Hibernate的继承映射(十四)_hibernate_11

四. 第三种方式

Hibernate的继承映射(十四)_Hibernate类表继承_12

Person父类表的id仍然可以是id. 这个时候，会自动增长的。可以不变。

<hibernate-mapping>
  <!--这里不能写abstract="true" 写入一个table标签。 会生成一个具体有用的表，会插入数据的。-->
  <class name="com.yjl.pojo.Person" table="person">
    <id name="id" column="id">
      <!--可以用自动增长-->
      <generator class="native"></generator>
    </id>
    <property name="name" column="name"></property>
    <property name="sex" column="sex"></property>
    <property name="age" column="age"></property>
  </class>
  <!-- 用的是joined-subclass -->
  <joined-subclass name="com.yjl.pojo.Student" table="student"
  extends="com.yjl.pojo.Person">
    <!-- 引入id -->
    <key column="id"></key>
    <!-- 学生的独特属性 -->
    <property name="stuNo" column="stuNo"></property>
    <!-- 如果有其他的独特属性，可以用property 继续往下写.-->
  </joined-subclass>
  <!-- 继续依次写其他的子类 -->
  <joined-subclass name="com.yjl.pojo.Teacher" table="teacher"
  extends="com.yjl.pojo.Person">
    <key column="id"></key>
    <!-- 教师的独特属性 -->
    <property name="salary" column="salary"></property>
  </joined-subclass>
</hibernate-mapping>

生成表的代码运行成功之后:

Hibernate的继承映射(十四)_Hibernate类表继承_13

在插入的代码测试之后:

Hibernate的继承映射(十四)_Hibernate类表继承_14

Hibernate的继承映射(十四)_Hibernate类表继承_15

Hibernate的继承映射(十四)_Hibernate单表继承_16

Hibernate的继承映射(十四)_Hibernate单表继承_17

查询的时候，与第二种方式一样。不做介绍了。

五优缺点比较

第一种方式:
优点:数据结构清晰
缺点:两个子表的主键不能重复，不能使用数据库的自增方式生成主键。
第二种方式:
优点:：查询效率高，符合数据库设计粗粒度
缺点:存在冗余字段，有些字段是子类不具有的属性。
第三种方式:
优点: 数据结构清晰，没有冗余
缺点: 类的继承层次比较多的话，造成生成的表也比较多，增删改查效率低下
根据业务需求，进行选择。推荐使用第二种方式。

谢谢!!!

上一篇：jQuery前端基本验证(一)

下一篇：Hibernate的一级缓存和二级缓存(七)

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯