Hibernate的继承映射(十四)-阿里云开发者社区

一.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来进行处理。

有三种方案:

1.一个子类对应一张表

2.使用一张表，表示所有继承体系下类的属性的并集

3.每一个子类使用一张表，记录它的独特属性，与父类所对应的表以一对一的方式关联起来。

二.第一种方案继承映射

来源于:音①晓前辈

二.一父类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();
  }

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

@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();
  }

注意观察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());
  }

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

三. 第二种继承映射

这种映射是放在同一张表里面。所以，父类中的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>

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

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

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

读取时:

@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");
    }
  }

四. 第三种方式

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的继承映射(十四)

二.一父类Person

二.二子类Student

二.三子类Teacher

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

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

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

三. 第二种继承映射

四. 第三种方式

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Hibernate的继承映射(十四)

二.一 父类Person

二.二 子类Student

二.三 子类Teacher

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

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

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

三. 第二种继承映射

四. 第三种方式

热门文章

最新文章

相关电子书

二.一父类Person

二.二子类Student

二.三子类Teacher

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

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

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