继承映射

最新推荐文章于 2023-04-14 16:21:15 发布

kkgs

最新推荐文章于 2023-04-14 16:21:15 发布

阅读量145

点赞数

分类专栏： Hibernate 文章标签：继承映射

本文链接：https://blog.csdn.net/m0_38113064/article/details/100529430

版权

Hibernate 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

继承映射

每个子类一张表(Table per class)策略: 在Hibernate中对应<union-class>元素:
每个类层次结构一张表(Single table per class hierarchy)策略:在Hibernate中对应<subclass>元素
连接的子类(Joined- subclasses)策略:在Hibernate中对应 <joined-subclass>元素

1. 每个类层次结构一张表

package com.kkgs.hibernate.pojo;

public class Animal {

    private int id;
    private String name;
    private int sex;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSex() {
		return sex;
	}
	public void setSex(int sex) {
		this.sex = sex;
	}
    
}

package com.kkgs.hibernate.pojo;

public class Bird extends Animal{

    private int height;

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}
}

package com.kkgs.hibernate.pojo;

public class Pig extends Animal{

    private String weight;

	public String getWeight() {
		return weight;
	}

	public void setWeight(String weight) {
		this.weight = weight;
	}
}

animal.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.kkgs.hibernate">
	<class name="com.kkgs.hibernate.pojo.Animal" abstract="true">
		<id name="id">
			<generator class="assigned"></generator>
		</id>
		<!-- 指明鉴别器 -->
		<discriminator column="type" type="string"></discriminator>
		<property name="name"></property>
		<property name="sex"></property>
		
		<subclass name="com.kkgs.hibernate.pojo.Bird"  discriminator-value="B">
			<property name="height"></property>
		</subclass>
		<subclass name="com.kkgs.hibernate.pojo.Pig"  discriminator-value="P">
			<property name="weight"></property>
		</subclass>
	</class>
</hibernate-mapping>

说明：
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。
用hibernate实现这种策略的时候，有如下步骤：
1、父类用普通的<class>标签定义
2、在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
3、子类使用标签定义，在定义subclass的时候，需要注意如下几点：

Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值
Subclass既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。
子类的其它属性，像普通类一样，定义在subclass标签的内部。
关于鉴别值在存储的时候hibernate会自动存储，在加载的时候会根据鉴别值取得相关的对象

优点：有区分子类的字段，也有描述其他字段的字段，子类的属性不能为空，维护方便，只需修改一张表。
缺点：灵活性差，表中冗余字段会随着子类的增多而越来越多

2. 每个子类一张表

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.kkgs.hibernate">
	<class name="com.kkgs.hibernate.pojo.Animal" abstract="true">
		<id name="id">
			<generator class="assigned"></generator>
		</id>
		<!-- 指明鉴别器 -->
		<!-- <discriminator column="type" type="string"></discriminator> -->
		<property name="name"></property>
		<property name="sex"></property>
		<union-subclass name="com.kkgs.hibernate.pojo.Bird" >
			<property name="height"></property>
		</union-subclass>
		<union-subclass name="com.kkgs.hibernate.pojo.Pig">
			<property name="weight"></property>
		</union-subclass>
	</class>
</hibernate-mapping>

在这里插入图片描述

说明：
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。
实现这种策略的时候，有如下步骤：
1、父类用普通<class>标签定义即可
2、子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：

union-subclass标签不再需要包含key标签（与joined-subclass不同）
union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当union-subclass标签的定义与class标签平行的时候，需要在union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。
子类的其它属性，像普通类一样，定义在union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。

注意：在保存对象的时候id不能重复（不能使用数据库的自增方式生成主键）

优点：映射灵活行大，子类可以包括基类属性在内的每一个属性进行单独配置，对于子类的查询只需要访问单独的表，对于大个对象持久化操作只需要处理一个表。
缺点：存在重复字段的问题，如果需要对基类进行修改，则需要对基类以及该类的子类所对应的所有表都进行修改。对父类查询需要查询所有的表。

3. 连接的子类(Joined- subclasses)

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.kkgs.hibernate">
	<class name="com.kkgs.hibernate.pojo.Animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 指明鉴别器 -->
		<!-- <discriminator column="type" type="string"></discriminator> -->
		<property name="name"></property>
		<property name="sex"></property>
		<!-- 此标签是表明子类的列 name:子类的类名 discriminator-value="stu"是由hibernate维护Student的type的值 -->
		
		<joined-subclass name="com.kkgs.hibernate.pojo.Bird" >
			<key column="birdId"/>
			<property name="height"></property>
		</joined-subclass>
		
		<joined-subclass name="com.kkgs.hibernate.pojo.Pig">
			<key column="pigId"/>
			<property name="weight"></property>
		</joined-subclass>
	</class>
</hibernate-mapping>

在这里插入图片描述

说明：
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。
实现这种策略的时候，有如下步骤：
1、父类用普通的标签定义即可
2、父类不再需要定义discriminator字段
3、子类用标签定义，在定义joined-subclass的时候，需要注意如下几点：

joined-subclass标签的name属性是子类的全路径名
joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当joined-subclass标签的定义与class标签平行的时候，需要在joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

优点：完全复合关系模型的设计原则，不存在冗余，维护方便，修改类的时候只修改其所对应的类。灵活性好。
缺点：父类查询需要使用左外链接，子类查询需要使用内链接，子类的持久化至少需要处理两个表。

创建工厂，工厂比较大而笨重，一般只创建一次(所以一般在listener中创建出)。
项目中，使用的的filter中是使用初始化的方法将数据进行初始化。
持久层（hibernate），持久化，自动生成表，开始向表中添加数据.向表中添加信息,struts标签.

懒加载：真正使用对象的时候才会去使用的时候，才会去访问数据库。

类上的懒加载：支持类上的懒加载的方法使用的就是load方法。
Load退化成为get，load支持懒加载，类上的懒加载只对propertiy标识的普通属性有效。
在set集合上的懒加载，只有使用该集合的数据的时候，才发送sql语句，访问对方的表。Set集合放上student的对象。

单端上的懒加载，配置在many-to-one 和one-to-one上面，当访问指定的字段的时候，才会去访问对应的数据。当真正的想使用单端上的数据，才访问另一个表。
默认情况下hibernate是开启懒加载的。当真正使用关联属性所表示的值得时候，才会去访问相关的表。

Lazy只用在加载上。Inverse和cascade主要用在加载上。Cglib的代理，有一个变量target。Cglib主要用在类上的懒加载上，复写到set集合上。

类上的懒加载详解：
User生成一个数据库，创建出一个表，表中有对应的字段。真实的项目，tomcat一启动就会创建出对应的项目。创建出对应的表。测试，加载测试数据，往表中存储数据，开启事务，创建相应的对象。
将lazy设计成false，就能够关闭懒加载对类上的影响。Load支持类上的懒加载，前提是类上的懒加载为true。

懒加载的异常：

·当session关闭的时候，懒加载还没有使用，产生的lazy异常。
Session采用方式：
·一般采用的是，改变session的生存周期的方法，一般在filter中配置。

使用threadLocal，将每一个session绑定到对应的数据中，每个用户拿到绑定的session。
原理，多个线程，去拿对应的session，多个并发的线程访问，并行的操作，将并行的线程变成串行。
·ThreadLocal技术，完成了线程和session的绑定，将并行变成了串行。
使用线程安全的map进行绑定，通过key进行绑定，取得当前线程绑定的value，session安全，使用懒加载拦截器（将session变成线程安全的）。
OpenSessionInView，解决懒加载拦截。

kkgs

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
继承映射

继承映射每个子类一张表(Table per class)策略: 在Hibernate中对应<union-class>元素:每个类层次结构一张表(Single table per class hierarchy)策略:在Hibernate中对应<subclass>元素连接的子类(Joined- subclasses)策略:在Hibernate中对应 <joine...
复制链接

扫一扫