06. 继承关系映射

最新推荐文章于 2020-03-15 07:45:47 发布
最新推荐文章于 2020-03-15 07:45:47 发布
阅读量224 收藏 1
点赞数
分类专栏： Hibernate 文章标签： 继承关系映射 Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_37976731/article/details/80504139
版权

继承关系映射

继承关系映射分为三种：

  • 整个继承结构映射一张表

  • 每个类映射一张表

    有多少个类就映射多少张表，包括子类父类

  • 每个具体子类映射一张表

    只需要每个子类映射一张表，而父类不映射到表

用到的例子

在研究继承关系映射时，我们用到了一个继承关系的例子。

父类：BillingDetails（账单明细）

  • id：Long

  • owner：String（拥有者）

  • code：String（卡号）

  • created：Date（创建时间）

  • setter、getter方法

子类：BankAccount（银行账户）

  • bankName：String（银行名称）

  • bankSwift：String（银行的简称）

子类：CreditCard（信用卡）

  • type：String（信用卡类型）

  • expMonth：String（有效时间，月份）

  • expYear：String（有效时间，年份）

BillingDetails类

package com.li.inheritance.pojo;

import java.io.Serializable;
import java.util.Date;

public class BillingDetails implements Serializable{

    private Long id;
    private String owner;
    private String code;
    private Date created;


    public BillingDetails() {
        super();
    }
    public BillingDetails(Long id, String owner, String code, Date created) {
        super();
        this.id = id;
        this.owner = owner;
        this.code = code;
        this.created = created;
    }

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getOwner() {
        return owner;
    }
    public void setOwner(String owner) {
        this.owner = owner;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public Date getCreated() {
        return created;
    }
    public void setCreated(Date created) {
        this.created = created;
    }
    @Override
    public String toString() {
        return "BillingDetails [id=" + id + ", owner=" + owner + ", code=" + code + ", created=" + created + "]";
    }



}

CreditCard类

package com.li.inheritance.pojo;

import java.io.Serializable;
import java.util.Date;

public class CreditCard extends BillingDetails implements Serializable {
    private String Type;
    private String expMonth;
    private String expYear;

    public CreditCard() {}

    public CreditCard(Long id, String owner, String code, Date created, String type, String expMonth, String expYear) {
        /*调用父类的构造方法*/
        super(id, owner, code, created);
        Type = type;
        this.expMonth = expMonth;
        this.expYear = expYear;
    }

    public String getType() {
        return Type;
    }

    public void setType(String type) {
        Type = type;
    }

    public String getExpMonth() {
        return expMonth;
    }

    public void setExpMonth(String expMonth) {
        this.expMonth = expMonth;
    }

    public String getExpYear() {
        return expYear;
    }

    public void setExpYear(String expYear) {
        this.expYear = expYear;
    }

    @Override
    public String toString() {
        return "CreditCard [Type=" + Type + ", expMonth=" + expMonth + ", expYear=" + expYear + "]";
    }

}

BankAccount类

package com.li.inheritance.pojo;

import java.io.Serializable;
import java.util.Date;

public class BankAccount extends BillingDetails implements Serializable {
    private String bankName;
    private String bankSwift;

    public BankAccount() {}

    public BankAccount(Long id, String owner, String code, Date created, String bankName, String bankSwift) {
        super(id, owner, code, created);
        this.bankName = bankName;
        this.bankSwift = bankSwift;
    }


    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public String getBankSwift() {
        return bankSwift;
    }

    public void setBankSwift(String bankSwift) {
        this.bankSwift = bankSwift;
    }

    @Override
    public String toString() {
        return "BankAccount [bankName=" + bankName + ", bankSwift=" + bankSwift + "]";
    }


}

整个映射结构映射到一张表

此方式支持多态，根据父类查找一个子类信息能查找到

表结构
CREATE TABLE t_hierarchy(
    id NUMBER(10) PRIMARY KEY,
    owner VARCHAR2(15),
    code VARCHAR2(15),
    created DATE,
    bankname VARCHAR2(20),
    bankswift VARCHAR2(20),
    credit_card_type VARCHAR2(20),
    expired_month VARCHAR2(20),
    expired_year VARCHAR2(20),
    account_type VARCHAR2(20)
);

这张表结构存储了整个继承结构的内容，包含了父类和子类的内容，而最后一列 “account_type” 用以区分记录的来源，记录可以来源于父类（BilliingDetails），也可以是子类BankAccount、子类CreditCard，我们把此列作为一个标识。

映射文件

  • discriminator-value：每个类的唯一标识，区分记录的来源

  • discriminator：name属性标明表中用来区分记录来源的栏位，type指明了类型，如下：如果ACCOUNT_TYPE的值为CC，则说明该记录是通过CreditCard映射过来的

  • subclass：配置子类

  • 主键生成策略只需配置父类即可，主键也在父类中

<class name="BillingDetails" table="t_hierarchy" discriminator-value="BD">
    ...
    <discriminator column="ACCOUNT_TYPE" type="string"/>
    ...
    <subclass name="CreditCard" discriminator-value="CC">...</subclass>
    <subclass name="BankAccount" discriminator-value="BA">...</subclass>
</class>

hierarchy.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>

    <class name="com.li.inheritance.pojo.BillingDetails" table="T_HIERARCHY" discriminator-value="BD">
        <id name="id" column="ID" type="long">
            <generator class="assigned"></generator>
        </id>
        <discriminator column="ACCOUNT_TYPE" type="string"></discriminator>
        <property name="owner" column="OWNER" type="string"></property>
        <property name="code" column="CODE" type="string"></property>
        <property name="created" column="CREATED" type="string"></property>

        <subclass name="com.li.inheritance.pojo.CreditCard" discriminator-value="CC">
            <property name="type" column="CREDIT_CARD_TYPE" type="string"></property>
            <property name="expMonth" column="EXPIRED_MONTH" type="string"></property>
            <property name="expYear" column="EXPIRED_YEAR" type="string"></property>
        </subclass>

        <subclass name="com.li.inheritance.pojo.BankAccount" discriminator-value="BA">
            <property name="bankName" column="BANKNAME" type="string"></property>
            <property name="bankSwift" column="BANKSWIFT" type="string"></property>
        </subclass>
    </class>

</hibernate-mapping>
测试
package com.li.inheritance.pojo;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.li.common.HibernateSessionFactory;

public class HierarchyTest {

    public static void main(String[] args) {
        BillingDetails bd=new BillingDetails();
        bd.setId(123L);
        bd.setCode("111");
        bd.setOwner("Lin");
        bd.setCreated(new Date(System.currentTimeMillis()));

        BankAccount ba=new BankAccount();
        ba.setBankName("ChinaBank");
        ba.setBankSwift("cnb");
        ba.setCreated(new Date(System.currentTimeMillis()));
        ba.setId(456L);
        ba.setCode("222");
        ba.setOwner("White");

        CreditCard cc=new CreditCard();
        cc.setId(789L);
        cc.setCode("333");
        cc.setOwner("Lucy");
        cc.setCreated(new Date(System.currentTimeMillis()));
        cc.setExpMonth("6");
        cc.setExpYear("2018");

        Session session = HibernateSessionFactory.getSession();
        Transaction trans=null;

        try {
            trans=session.beginTransaction();
            session.save(bd);
            session.save(ba);
            session.save(cc);

            BillingDetails account=(BillingDetails) session.get(BankAccount.class, 456L);
            /*多态，下面这种方式能通过父类查找到子类*/
            BillingDetails account=(BillingDetails) session.get(BillingDetails.class, 456L);
            System.out.println(account);

            trans.commit();
        } catch (Exception e) {
            e.printStackTrace();
            trans.rollback();
        }
    }

}

数据库记录

这里写图片描述

改进

实际上我们创建一个父类（BillingDetails）对象并持久化到数据库中没有任何意义，因为子类就包括了父类的所有信息，而父类映射到数据库中没有实际意义，所以我们通常将父类声明为抽象类，那么我们就不能是哟 new 关键字来实例化父类了。

每个类映射一张表

此方式支持多态，根据父类查找一个子类信息能查找到

表结构

表名中间加join是因为我们的操作中有join操作。我们把子表中的主键又作为外键映射到父表中的主键，实现了表与表的关联。

t_join_billingdetails表（父表）

CREATE TABLE t_join_billingdetails(
    id NUMBER(10) PRIMARY KEY,
    owner VARCHAR2(15),
    code VARCHAR2(15),
    created DATE
);

t_join_bankaccount表（子表）

CREATE TABLE t_join_bankaccount(
    billing_id NUMBER(10) PRIMARY KEY,
    bankname VARCHAR2(20),
    bankswift VARCHAR2(20),
    FOREIGN KEY(billing_id) REFERENCES t_join_billingdetails(id)
);

t_join_creditcard表（子表）

CREATE TABLE t_join_creditcard(
    billing_id NUMBER(10) PRIMARY KEY,
    credit_card_type VARCHAR2 (20),
    expired_month VARCHAR2 (20),
    expired_year VARCHAR2 (20),
    FOREIGN KEY(billing_id) REFERENCES t_join_billingdetails(id)
);
映射文件

join.hbm.xml映射文件，完成之后配置到核心配置文件中

其中key标签设置表对应的外键列。

<?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 package="com.li.inheritance.pojo">
    <class name="BillingDetails" table="T_JOIN_BILLINGDETAILS">
        <id name="id" column="ID" type="long">
            <generator class="assigned"></generator>
        </id>
        <property name="owner" column="OWNER" type="string"></property>
        <property name="code" column="CODE" type="string"></property>
        <property name="created" column="CREATED" type="string"></property>

        <joined-subclass name="CreditCard" table="T_JOIN_CREDITCARD">
            <key column="BILLING_ID"/>
            <property name="type" column="CREDIT_CARD_TYPE" type="string"></property>
            <property name="expMonth" column="EXPIRED_MONTH" type="string"></property>
            <property name="expYear" column="EXPIRED_YEAR" type="string"></property>
        </joined-subclass>
        <joined-subclass name="BankAccount" table="T_JOIN_BANKACCOUNT">
            <key column="BILLING_ID"/>
            <property name="bankName" column="BANKNAME" type="string"></property>
            <property name="bankSwift" column="BANKSWIFT" type="string"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

每个具体子类映射一张表

此方式不支持多态，根据父类查找一个子类信息不能查找到

表结构

concrete：混泥土，表示具体的意思

t_concrete_bankaccount表

CREATE TABLE t_concrete_bankaccount(
    id NUMBER(10) PRIMARY KEY,
    owner VARCHAR2(15),
    code VARCHAR2(15),
    created DATE,
    bankname VARCHAR2(20),
    bankswift VARCHAR2(20)
);

t_concrete_creditcard表

CREATE TABLE t_concrete_bankaccount(
    id NUMBER(10) PRIMARY KEY,
    owner VARCHAR2(15),
    code VARCHAR2(15),
    created DATE,
    credit_card_type VARCHAR2(20),
    expired_month VARCHAR2(20),
    expired_year VARCHAR2(20)
);
映射文件

concrete.hbm.xml

最外层的class指定父类，但是父类不映射表结构，所有无需配置对应的表，还配置对应的主键生成策略和属性。

对子类我们使用union-subclass来配置，子类独有的属性我们需要配置在子类中

完成映射文件，再把映射文件配置到核心配置文件中hibernate.cfg.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 package="com.li.inheritance.pojo">
    <class name="BillingDetails">
        <id name="id" column="ID" type="long">
            <generator class="assigned"></generator>
        </id>
        <property name="owner" column="OWNER" type="string"></property>
        <property name="code" column="CODE" type="string"></property>
        <property name="created" column="CREATED" type="string"></property>

        <union-subclass name="CreditCard" table="T_CONCRETE_CREDITCARD">
            <property name="type" column="CREDIT_CARD_TYPE" type="string"></property>
            <property name="expMonth" column="EXPIRED_MONTH" type="string"></property>
            <property name="expYear" column="EXPIRED_YEAR" type="string"></property>
        </union-subclass>
        <union-subclass name="BankAccount" table="T_CONCRETE_BANKACCOUNT">
            <property name="bankName" column="BANKNAME" type="string"></property>
            <property name="bankSwift" column="BANKSWIFT" type="string"></property>
        </union-subclass>
    </class>
</hibernate-mapping>

继承关系小结

分类多态更新维护出具报表
整个继承结构映射一张表支持难易
每个类映射一张表支持易难
每个具体子类映射一张表不支持难易

多态：即一张表中存储多种类型的记录

不支持多态的用的不多，其中第二种用的更多一点

「已注销」
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
精通Hibernate之映射继承关系（三）
02-22
这种映射方式只需为继承关系树的Employee根类创建一张表EMPLOYEES。如图14-4所示，在EMPLOYEES表中不仅提供和Employee类的属性对应的字段，还要提供和它的两个子类的所有属型对应的字段，此外，EMPLOYEES表中需要...
面向对象中继承的几种方式
Femi的博客欢迎大家
06-10 1516
//父类 // 定义一个动物类 function Animal (name) { // 属性 this.name = name || 'Animal'; // 实例方法 this.sleep = function(){ console.log(this.name + '正在睡觉！'); } } // 原型方法 Animal.prototype.eat = funct...
Hibernate（十一）：映射继承关系的三种方案
weixin_34006965的博客
06-08 148
背景： 　　在一些项目中，会采用集成的关系来定义数据库实体类，比如:人（Person）与学生(Student)，学生来源与人，所以人的基本属性学生也拥有；但学生有的一些属性，人就不具有。人与学生之间很显然就拥有了继承关系------学生继承于人，人是父类，学生是子类。 　　那么，这种继承关系在hibernate是如何映射呢？ 　　对于面向对象的程序设计语言而言，继承和多态是两个最基本...
Hibernate笔记=>继承关系的映射
天下无双
04-25 1198
http://blog.sina.com.cn/s/blog_3d7bed65010004lx.html在Java或.Net类与类之间存在关联、聚集和继承关系。一般来说：关联关系：采用“一对多或一对一”的映射即可；聚集关系：采用“集和映射”，即映射Set,Bag,List,Map继承关系：本文以下详述 因为关系数据库的表之间不存在继承关系，所以Hibernate
继承映射的三种方式
weixin_30381793的博客
07-30 172
JPA中有三种方式：SINGLE_TABLE,TABLE_PER_CLASS,JOINED 转载于:https://www.cnblogs.com/seven7seven/p/3877846.html
Hibernate映射继承关系的三种方式(1)zt
软软的沙窝！小憩的场所！
01-09 234
Company类和Employee类之间为一对多的双向关联关系(假定不允许雇员同时在多个公司兼职)，Employee为抽象类因此不能被实例化，它有两个具体的子类；HourlyEmployee类和SalariedEmployee类。 由于Java只允许一个类最多有一个直接的父类，因此Employ类、HourlyEmployee类和SalariedEmployee类构成了一棵继承关系树。   　　　...
精通Hibernate之映射继承关系（六）
02-04
Company与Employee类之间为一对多多态关联关系，如果继承关系树的根类对应一个表，或者每个类对应一个表，那么就能映射Company类的employees集合。本节介绍如何映射多对一多态关联。如图14-11所示，ClassD与ClassA为...
精通Hibernate之映射继承关系（五）
02-04
本章介绍的三种映射方式各有优缺点，表14-1对这三种映射方式做了比较。表14-1比较三种映射方式如果不需要支持多态查询和...图14-9复杂的继承关系树可以将图14-9的继承关系树分解为3棵子树：DOClass类、ClassA类和Clas
精通Hibernate之映射继承关系（四）
02-27
在这种映射方式下，继承关系树的每个类以及接口都对应一个表。在本例中，需要创建EMPLOYEES、HE和SE表。如图14-6所示，EMPLOYEES表仅包含和Employee类的属性对应的字段，HE表仅包含和HourlyEmployee类的属性对应的...
继承关系映射详解
张晓丛的专栏
12-14 1177
继承关系映射        继承在对象模型中是 is a（是一个）的关系，但在关系模型中，实际之间只有has a（有一个）的关系，也就是说，继承在对象模型和关系模型上是不匹配的，索性的是Hibernate提供了3中常用的继承映方案。 一．整个继承层次一张表 把整个继承层次的多个类的信息存放到一张表里。需要在表中添加一个特定字段，用这个字段的值来进行区分哪些记录是属于哪一个类的。
映射继承关系
超胆孤侠
12-21 357
继承映射对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。Hibernate 的继承映射可以理解持久化类之间的继承关系。例如：人和学生之间的关系。学生继承了人，可以认为学生是一个特殊的人，如果对人进行查询，学生的实例也将被得到三种映射Hibernate支持三种继承映射策略： 使用 subclass 进行映射：将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系数据模型中考虑
hibernate继承关系映射方法（三）--每个具体类一张表TPC
tuke_tuke的博客
11-28 2532
TPC:所谓是“每个具体类一张表(table per concrete class)”的意思是:使继承体系中每一个子类都对应数据库中的一张表。每一个子类对应的数据库表都包含了父类的信息，并且包含了自己独有的属性。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段。这种策略是使用标签来定义子类的。 注意：三个类+一个父类映射文件+两张表 st
继承关系映射
Konaji
01-27 548
继承关系映射
hibernate 映射继承关系的三种方法
岛丶
12-23 524
subclass:<hibernate-mapping package="com.atguigu.hibernate.subclass"> <class name="Person" table="PERSONS" discriminator-value="PERSON"> <id name="id" type="java.lang.Integer"> <c
Hibernate继承映射的三种方式
OVO_LQ_Start的博客
01-29 180
单表设计（SINGLE_TABLE） 将所有的表都放入父类的一张表中, 需要一个DiscriminatorColumn来区别不同的子类。 创建Person，Student，Teacher类Student和Teacher都继承Person。 Person类中使用@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 指定表的设计模式 @Discrimi...
C#系统开发之数据库设计-继承关系的建立
u012886185的博客
03-18 322
在实际的程序开发中，我们通常在后台程序设计的时候，用了大量抽象的东西，接口，抽象类等等，也用了继承和实现来快速扩展子类，这些都是为了让程序开发更加高效，模块化，易于分工协作等等；但是在数据库端如何实现这种继承关系呢？特别是针对于业务特别复杂的模型的时候，数据库的设计更加重要； 通常有三种方法来实现： 1 建立外键表，将所有子表共有的用于实现某一种功能的字段封装起来，比如将描述数据权限的字段封装...
2-19-怎么在数据库中表达面向对象中的继承关系
AlphaCat的博客
03-15 1013
1. EAV表（entity-Attribute-Value） 2. 单表继承 3. 实体表继承 4. 类表继承 5. 半结构化设计 1. EAV表（entity-Attribute-Value） createtable note_dictionary ( dictionary_idnumber, dictionary_type var...
Hibernate继承映射策略解析
这些策略用于将面向对象的继承关系映射到关系数据库中，以适应不同场景的需求。文档详细讲解了每种策略的实现方法、优缺点，并给出了具体的代码示例。" 在Java开发中，Hibernate是一个非常流行的ORM（对象关系映射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值