Hibernate的继承映射(十四)

最新推荐文章于 2022-05-30 10:37:12 发布

两个蝴蝶飞

最新推荐文章于 2022-05-30 10:37:12 发布

阅读量740

点赞数 1

分类专栏： Hibernate 文章标签： Hibernate继承映射 Hibernate单表继承 Hibernate具体表继承 Hibernate类表继承

转载请注明出处(两个蝴蝶飞)

本文链接：https://blog.csdn.net/yjltx1234csdn/article/details/88775539

版权

Hibernate 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

上一章简单介绍了Hibernate与Java的数据类型转换和对数组，集合的扩充(十三),如果没有看过,请观看上一章
参考了音①晓前辈的文章: http://www.cnblogs.com/otomedaybreak/archive/2012/01/26/2329809.html
以下所有的图片均来自于音①晓前辈。

一.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来进行处理。
有三种方案:

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

二.第一种方案继承映射

来源于:音①晓前辈
在这里插入图片描述

二.一父类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>

生成表的代码运行成功之后:
在这里插入图片描述
在插入的代码测试之后:

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

五优缺点比较

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

谢谢!!!