hibernate单表继承的三种实现方式详解

最新推荐文章于 2021-01-19 04:01:30 发布
最新推荐文章于 2021-01-19 04:01:30 发布
阅读量1.3k 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/do_bset_yourself/article/details/51067880
版权

多态是java的优势之一,这种常用的特性hibernate这种框架也做了一定的支持,这期我们就来探讨下,hibernate关于继承方面的实现:

首先说明hibernate对于继承有三种实现方式,也是按数据库中表继承的实现分类的,希望大家在看这篇文章是,去了解下关系数据库中的表继承的实现可能对于hibernate的继承以及对java的多态性会有很大的帮助和深入了解:

好,废话不多说,

继承和数据表的对应关系:



三种实现方式,:

   在设置继承结构的映射时,我们可以写三份配置文件,也可以写一份,一般是-份,三份需指定extends属性,
    一份时一般是写在父类的配置文件中
  discriminator-value属性：
			用于鉴别是哪个类的一个值，表示这个值就是这个类。
			如果不写，默认为类的全限定名。   
    继承有三种实现方式:一种是:所有子类和父类都保存在一张表中,通过一个元组鉴别三种类型:
    第二种是:三张表示,每个类都由一张表表示,使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接；
   		(重点):保存时子类时，会现在父类表中保存父类子类共有的属性，然后再子类自己的表中保存自己的属性
		这点一定要知道：
第三种是：每个子类都在数据库中对应一张表,父类声明为抽象类,无表对应,
		在配置文件中父类申明为抽象类，但在写父类javabean时，是不是抽象类都可以(属性abstract)，
		但是在配置文件一定要声明为抽象类，由于父类不对应table,所以当abstract=true,不要写table,
		写了hibernate也会自动忽略
		这时父类的作用更像是为了减少重复声明的存在一样
	(重点:)	这时每个子类的表中都会保存父类的子类的所有属性
		注意子类使用union-subclass标签;

这里我们采用论坛的类的继承来说明hibernate继承的实现方式:

我们先写三个java类,和测试类,

父类Article子类Reply和子类Topic

Article:

<span style="font-size:18px;">package hibernate_extends3;

import java.util.Date;

public class Article {
	private Integer id;
	private String title;
	private String content;
	private Date posttime;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}

	public Date getPosttime() {
		return posttime;
	}
	public void setPosttime(Date posttime) {
		this.posttime = posttime;
	}
	@Override
	public String toString() {
		return "Article [id=" + id + ", title=" + title + ", content="
				+ content + ", posttime=" + posttime + "]";
	}

	
}</span><span style="font-size:32px;">
</span>
Topic: 

package hibernate_extends3;



public class Topic extends Article {
	private Integer type;

	public Integer getType() {
		return type;
	}

	public void setType(Integer type) {
		this.type = type;
	}


	
	
	
}

Reply: 

package hibernate_extends3;

public class Reply extends Article {
	private Integer floor;

	public Integer getFloor() {
		return floor;
	}

	public void setFloor(Integer floor) {
		this.floor = floor;
	}


	
}

测试类: 

package hibernate_extends1;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {
	static SessionFactory sessionFactory=null;
	static{
		//加载配置文件
		sessionFactory=new Configuration().configure().
				addClass(Article.class).
				buildSessionFactory();
	}
	/**
	 *测试保存
	 */
	@Test
	public void testSave(){
		Session session=sessionFactory.openSession();
		session.beginTransaction();
		//新建对象
		Article article=new Article();
		article.setTitle("我是文章");
		article.setContent("我是文章内容");
		Reply replay=new Reply();
		replay.setTitle("我是回复");
		replay.setContent("我是回复内容");
		replay.setFloor(1);
		Topic topic=new Topic();
		topic.setTitle("我是主题");
		topic.setContent("我是主题内容");
		topic.setType(1);
		session.save(article);
		session.save(replay);
		session.save(topic);
		session.getTransaction().commit();
		session.close();
	}
	
	/**
	 * 测试获取
	 * 测试时,别忘记了,存取的顺序,不然会搞混reply和topic,导致获取失败,
	 * 鄙人过于粗心,导致拜拜浪费了3个小时,检查了两份文本,3个小时啊,大家要引以为鉴啊
	 */
	@Test
	public void testGet(){
		Session session=sessionFactory.openSession();
		session.beginTransaction();
		//新建对象
	Article article=(Article) session.get(Article.class, 1);
		Topic topic=(Topic) session.get(Topic.class, 3);
		Reply replay=(Reply) session.get(Reply.class, 2);
		System.out.println(article);
		System.out.println(topic);
		System.out.println(replay);
		
		
		///
	System.out.println();
		Article article1=(Article) session.get(Article.class, 2);
		Article article2=(Article) session.get(Article.class, 3);
		System.out.println(article1);
		System.out.println(article2);
		session.getTransaction().commit();
		session.close();
	}
}



一种是:所有子类和父类都保存在一张表中,通过一个元组鉴别三种类型,:

<span style="font-size:18px;"><?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-5 16:43:03 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="hibernate_extends1">
 <!--    在设置继承结构的映射时,我们可以写三份配置文件,也可以写一份,一般是一份,三份需指定extends属性,
    一份时一般是写在父类的配置文件中
    
    继承有三种实现方式:一种是:所有子类和父类都保存在一张表中,通过一个元组鉴别三种类型如下:
    discriminator-value属性：
			用于鉴别是哪个类的一个值，表示这个值就是这个类。
			如果不写，默认为类的全限定名。
     -->
    <class name="Article" table="article" discriminator-value="article">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="native" />
        </id>
        	<!-- 用于鉴别是什么类型的一个列 ,这里是指定鉴别元组的元组类型和名称-->
		<discriminator type="string" column="class_"></discriminator>
<!--         在设置字符串类型的值时建议指定长度,不然系统默认长度, -->
        <property name="title" type="string" length="40">
            <column name="title" />
        </property>
        <property name="content" type="text" length="1000">
            <column name="content" />
        </property>
        <property name="posttime" type="timestamp">
            <column name="posttime" />
        </property>
 <!--        子类Replay -->
        <subclass name="Reply" discriminator-value="Reply" >
            <property name="floor" type="int" column="floor"/>
        </subclass>
         <!--        子类Topic -->
        <subclass name="Topic" discriminator-value="Topic">
            <property name="type" type="int" column="type"></property>
        </subclass>
    </class>
</hibernate-mapping></span><span style="font-size:24px;font-weight: bold;">
</span>

第二种是:三张表示,每个类都由一张表表示,使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接；
    保存时子类时，会现在父类表中保存父类子类共有的属性，然后再子类自己的表中保存自己的属性
这点一定要知道： 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-5 16:43:03 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="hibernate_extends2">
 <!--    在设置继承结构的映射时,我们可以写三份配置文件,也可以写一份,一般是一份,三份需指定extends属性,
    一份时一般是写在父类的配置文件中
  discriminator-value属性：
			用于鉴别是哪个类的一个值，表示这个值就是这个类。
			如果不写，默认为类的全限定名。   
    继承有三种实现方式:一种是:所有子类和父类都保存在一张表中,通过一个元组鉴别三种类型:
    第二种是:三张表示,每个类都由一张表表示,使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接；
   		保存时子类时，会现在父类表中保存父类子类共有的属性，然后再子类自己的表中保存自己的属性
		这点一定要知道：
		具体实现如下:
     -->
    <class name="Article" table="article" >
        <id name="id" type="int">
            <column name="ID" />
            <generator class="native" />
        </id>
      
<!--         在设置字符串类型的值时建议指定长度,不然系统默认长度, -->
        <property name="title" type="string" length="40">
            <column name="title" />
        </property>
        <property name="content" type="text" length="1000">
            <column name="content" />
        </property>
        <property name="posttime" type="timestamp">
            <column name="posttime" />
        </property>
 <!--        子类Replay 
 使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接
 -->
       <joined-subclass name="Reply" table="reply">
            <key column="rid"></key>
           <property name="floor" type="int" column="type"></property>
       </joined-subclass>
       
       
         <!--        子类Topic 
         
         使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接
         -->
     <joined-subclass name="Topic" table="topic">
         <key column="tid"></key>
           <property name="type" type="int" column="type"></property>
       </joined-subclass>
    </class>
</hibernate-mapping>

第三种是：每个子类都在数据库中对应一张表,父类声明为抽象类,无表对应: 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-5 16:43:03 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="hibernate_extends3">
 <!--    在设置继承结构的映射时,我们可以写三份配置文件,也可以写一份,一般是一份,三份需指定extends属性,
    一份时一般是写在父类的配置文件中
  discriminator-value属性：
			用于鉴别是哪个类的一个值，表示这个值就是这个类。
			如果不写，默认为类的全限定名。   
    继承有三种实现方式:一种是:所有子类和父类都保存在一张表中,通过一个元组鉴别三种类型:
    第二种是:三张表示,每个类都由一张表表示,使用标签joined-class,多了一个属性,子类引用父类的主键,作为自己的主键,保证属性的连接；
   		(重点):保存时子类时，会现在父类表中保存父类子类共有的属性，然后再子类自己的表中保存自己的属性
		这点一定要知道：
第三种是：每个子类都在数据库中对应一张表,父类声明为抽象类,无表对应,
		在配置文件中父类申明为抽象类，但在写父类javabean时，是不是抽象类都可以(属性abstract)，
		但是在配置文件一定要声明为抽象类，由于父类不对应table,所以当abstract=true,不要写table,
		写了hibernate也会自动忽略
		这时父类的作用更像是为了减少重复声明的存在一样
	(重点:)	这时每个子类的表中都会保存父类的子类的所有属性
		注意子类使用union-subclass标签;
     -->
    <class name="Article" abstract="true">
        <id name="id" type="int">
            <column name="ID" />
       <!--     注意当父类为抽象类时,主键不可使用数据库自动生成,
           当使用每个具体类一张表的方式时，主键生成策略不能是identity。
				因为在整个继承结构中，主键值是不能重复的。 -->
            <generator class="assigned" />
        </id>
      
<!--         在设置字符串类型的值时建议指定长度,不然系统默认长度, -->
        <property name="title" type="string" length="40">
            <column name="title" />
        </property>
        <property name="content" type="text" length="1000">
            <column name="content" />
        </property>
        <property name="posttime" type="timestamp">
            <column name="posttime" />
        </property>
 <!--        子类Replay 
 使用标签union-subclass,将父类的属性连接到子类的表中
 -->
 <union-subclass name="Reply" table="reply">
     <property name="floor" column="floor" type="int"/>
 </union-subclass>
       
       
     <!--        子类Topic
 使用标签union-subclass,将父类的属性连接到子类的表中
 -->
     <union-subclass name="Topic" table="topic">
         <property name="type" type="int" column="type"></property>
     </union-subclass>
    </class>
</hibernate-mapping>



三种测试方式不太一样,注意事项,需要在理解的基础上,就会明白,唯一需要改变的就是第三种,注意父类是抽象类,大家可以尽情测试,了解hibernate


都市桃源
关注
专栏目录
hibernate 实现继承的三种方式
留住流失的记忆
09-28 491
1、继承关系中每个类都映射成一个数据库表，基类和子类共用一个id来标识。这样相当于父类和每个子类都对应自己单独的表结构。   优点就是完全符合面向对象思想，缺点是查询子类要级联查询多个表，效率低。配置文件例子：<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://
Hibernate继承策略
zylzb的专栏
10-27 578
Hibernate继承策略总共有三种，一种是共用一张表；一种是每个类一张表，表里面储存子类的信息和父类的信息；还有一种是通过表连接的方式，每个类都有一张表，但是子类对应的表只保存自己的信息，父类对应的表保存父类的信息，它们之间通过子类表和父类表的关联来获取所有的信息。 第一种方式，即共用一张表： @Entity @Inheritance(strategy=InheritanceType.SI
Hibernate的4种继承关系
不积跬步 无以至千里 不积小流 无以成江海
06-05 284
一、继承关系_整个继承树映射到一张表 对象模型(Java类结构) 一个类继承体系一张表(subclass)(表结构) Employee.java package com.taobao.hibernate.domain; public class Employee { private int id; private String name; private Depart...
hibernate表之间继承之 一张表
彻底拆分，一切可控！
10-06 580
1.建立基类 Person package com.dada.hibernate; import javax.persistence.DiscriminatorColumn; import javax.persistence.DiscriminatorType; import javax.persistence.DiscriminatorValue; import javax.per
hibernate映射继承关系（每个类都对应一张表）
11-28
hibernate实现继承关系映射的方式有三种，这种方式是将每个类都映射成一张表。
hibernate继承映射.rar
01-14
《Hibernate继承映射详解》 Hibernate，作为Java领域中的一款著名对象关系映射（ORM）框架，极大地简化了数据库操作。在实际项目中，我们常常会遇到类的继承关系，而Hibernate提供了强大的支持来处理这种继承关系的...
hibernate对应关系详解
01-03
6. **继承关系映射**：Hibernate支持类的继承关系映射，包括单表继承（Single Table Inheritance）、联合继承（Concrete Table Inheritance）和歧视值继承（Discriminator Value Inheritance）。单表继承所有子类...
Hibernate继承映射策略详解与最佳实践
通常情况下，继承映射可以分为单表继承映射和多表继承映射两种策略。Hibernate提供了丰富的映射方式来满足不同的需求，开发人员可以根据具体情况选择合适的继承映射策略。 --- ## 1.2 单表继承映射策略介绍 单表...
Hibernate annotation 详解
03-16
Hibernate支持单表继承（SINGLE_TABLE）、联合表继承（JOINED）和表-per-class策略。使用`@Inheritance`和`@DiscriminatorColumn`进行配置。 9. **回调事件(@PrePersist, @PostLoad等)** 这些注解可以用于监听对象...
hibernate继承之一，单表继承映射
呱哇鸟
03-23 120
hibernate继承之一，单表继承映射     对象有继承，而对于数据结构来说，如何在映射中体现这种关系。借助hibernate，我们在对表的映射中能够体现这种关系和设计。     相信我们在设计表的时候经常有这种情况，会用一个type字段来表示这张表的两种形式。而反映到java对象中，其实应该是两个对象，不过有很多相同的共同属性。但实际一般来说都会只用一个类，在查询是用type指定值来...
Hibernate继承映射详解
鹏霄万里展雄飞
02-21 2372
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继承体系下
Hibernate中数据库表的继承关系
05-17 233
继承这个词多半用在OOP编程里，比如类的继承，但是在Hibernate里表也有继承关系，这也难怪，因为Hibernate的目的就是要把数据库对象化。    先来看一个简单的例子，一个人员表Person，这张表里主要纪录一些公司人员的基本信息；还有一张用户表User，这张表纪录的是公司里的人员登陆公司网站的用户名信息表；很显然用户来源于人员，一个人员可以有多个用户，而一个用户只对应一个人员，这样U...
【Hibernate集锦】---继承映射之单表继承
思想上移，行动下移
10-25 1768
package com.test.hibernate; /** * 父类：User * @author WYQ * */ public class User { //用户id号 private int id; //姓名 private String name; //性别:1.女 2.男 private int sex; //年龄 private int ag
hibernate映射表中的继承关系
RANJIANGCHENG的博客
08-23 439
在hibernate中，对于映射表有三种映射继承关系：1.subclass类型：这种类型是将有继承关系的多个实体类放到同一张数据表中，在映射表中通过添加辨别列加以区分各个不同的对象，对于子类独有的字段，在父类对象中是为空的。优点： 1. 只用一张数据表，便与查询 2.查询性能较好 缺点： 1.子类独有的字段在数据表中不能添加非空的限制 2.当继承关系较深的时候，在数据表中的字段会变得很多，
hibernate单表继承映射
想念的专栏
08-15 448
hibernate支持三种基本的继承映射策略： 1、每个类分层结构一张表映射 2、每个子类一张表映射 3、每个具体类一张表映射 我们先来分析第一种策略，假设有一个父类Person，它有两个子类Teacher和Student，都继承了Person类，如图： 我们可以把这种关系的数据，设计到一张表中展示，如图： 下面我们来看下怎样来实现实体类和对应的映射关系来生成这张表。
【SSH快速进阶】——Hibernate继承映射：每个具体类映射一张表
点滴汇聚，智在积累。——Danny
02-20 2739
【Hibernate继承映射综合分析】 如果系统需要经常进行查操作且子类数量较多，则建议用第一种方案，即每棵生成树映射一张表，这也是最常用的方法，效率较高。 如果追求细粒度的设计且子类数量不多，则可以用后两种方案：每个类映射一张表或每个具体类映射一张表。
mysql 表的继承_对象的继承关系在关系型数据库表中的表示---继承表的概述与使用方式...
weixin_31894867的博客
01-19 1364
在数据库表中实现表继承一般来说有3种实现方式： Concrete Table Inheritance(具体表继承) Single Table Inheritance(单表继承) Class Table Inheritance(类表继承)。比如有一只鸭子，它有属性是：动物，会叫，两只脚。来了一只可达鸭(除了鸭的属性，还有会唱可达歌)，又来了一只大黄鸭(除了鸭的属性，会跳大黄鸭之舞)，它们各有各自的属...
Hibernate 继承
bluethirdbank的博客
11-29 171
  在域模型中，类与类之间除了关联关系和聚集关系，还可以存在继承关系，在下图所示的域模型中，Deparment类和Employee类之间为一对多的 双向关联关系，Employee类有两个子 类：Skiller类和Sales类。由于Java只允许一个类最多有一个直接的父类，因此Employee类、 Skiller类和Sales类构成了一棵继承关系树。 在 面向对象的范畴中，还存在多态的概念，多态建...
Hibernate继承映射详解：实例分解与表设计
当一个类继承自另一个或多个类时，Hibernate支持将这种继承关系映射到数据库中的多个表，每个子类对应一个独立的表，以实现数据的分离和效率优化。 在这个例子中，我们首先需要创建三个表：EMPLOYEES、HE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值