Hibernate学习(3) (继承映射,配置文件和注解版)

于 2017-05-28 12:48:02 发布
阅读量1.6k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： hibernate学习笔记 文章标签： hibernate 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shengge01/article/details/72790985
本文详细介绍了Hibernate中如何处理内存对象的继承关系映射到数据库，包括MappedSuperclass、Single Table、Joined Table和Table per Class四种策略。每种策略的特点和优缺点进行了分析，例如单表映射可能导致数据冗余，而 Joined Table 在数据量大时可能影响性能。文章以官方示例和注解配置文件为载体，深入讲解了各种映射方式的实现方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这篇blog准备写怎样在Hibernate中反应内存对象之间的继承关系.我们知道,内存对象之间是可以有继承关系的,但是在数据库中,我们继承神马的都是浮云,不存在的.那么怎么办呢?Hibernate提供了继承关系映射!(其实就是帮你把原来的一个类以一种特定的方式存储在数据库中.)
我们以官方的例子为例:
这里写图片描述
分为四种方式:
1. MappedSuperclass
被继承的表在数据库中不映射.

    @MappedSuperclass
public static class Account {

    @Id
    private Long id;

    private String owner;

    private BigDecimal balance;

    private BigDecimal interestRate;

    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 BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }

    public BigDecimal getInterestRate() {
        return interestRate;
    }

    public void setInterestRate(BigDecimal interestRate) {
        this.interestRate = interestRate;
    }
}

@Entity(name = "DebitAccount")
public static class DebitAccount extends Account {

    private BigDecimal overdraftFee;

    public BigDecimal getOverdraftFee() {
        return overdraftFee;
    }

    public void setOverdraftFee(BigDecimal overdraftFee) {
        this.overdraftFee = overdraftFee;
    }
}

@Entity(name = "CreditAccount")
public static class CreditAccount extends Account {

    private BigDecimal creditLimit;

    public BigDecimal getCreditLimit() {
        return creditLimit;
    }

    public void setCreditLimit(BigDecimal creditLimit) {
        this.creditLimit = creditLimit;
    }
}   
CREATE TABLE DebitAccount (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    overdraftFee NUMERIC(19, 2) ,
    PRIMARY KEY ( id )
)

CREATE TABLE CreditAccount (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    creditLimit NUMERIC(19, 2) ,
    PRIMARY KEY ( id )
)

没有创建Acount表,但是Account的属性在每个子类的数据库表中都存在.
2. Single table
单表映射,所有的类映射到数据库中的一个表
Annotation版本:

@Entity(name = "Account")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public static class Account {

    @Id
    private Long id;

    private String owner;

    private BigDecimal balance;

    private BigDecimal interestRate;

    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 BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }

    public BigDecimal getInterestRate() {
        return interestRate;
    }

    public void setInterestRate(BigDecimal interestRate) {
        this.interestRate = interestRate;
    }
}

@Entity(name = "DebitAccount")
public static class DebitAccount extends Account {

    private BigDecimal overdraftFee;

    public BigDecimal getOverdraftFee() {
        return overdraftFee;
    }

    public void setOverdraftFee(BigDecimal overdraftFee) {
        this.overdraftFee = overdraftFee;
    }
}

@Entity(name = "CreditAccount")
public static class CreditAccount extends Account {

    private BigDecimal creditLimit;

    public BigDecimal getCreditLimit() {
        return creditLimit;
    }

    public void setCreditLimit(BigDecimal creditLimit) {
        this.creditLimit = creditLimit;
    }
}
CREATE TABLE Account (
    DTYPE VARCHAR(31) NOT NULL ,
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    overdraftFee NUMERIC(19, 2) ,
    creditLimit NUMERIC(19, 2) ,
    PRIMARY KEY ( id )
)

Account Table:

DTYPEidbalanceownerinterestRateoverdraftFeecreditLimit
描述列(表明这是什么类的实例对象)主键Account属性Account属性Account属性DebitAccount属性(CreditAccount中为空)CreditAccount属性(在DebitAccount中为空)

Single table版本,需要在Account表格中添加所有子类可能的属性以及对于类的描述性列(,因为子父类都在一个表中,我们需要知道一个元组是什么类,所以必须有一个描述列更多关于描述列,这里DTYPE即是它的描述性列,只能为String,Char,INTEGER),因此会有大量的数据冗余.

注解版本使用另外三个类:
Plane(父类),Airbus(子类),Boeing(子类)

public class Plane {
    private Long id;
    private String type;
    private String manufacturer;
    public Plane() {}
    public Long getId() { return id; }
    private void setId(Long id) { this.id = id; }
    public String getType() { return type; }
    public void setType(String type) { 
        this.type = type; 
    }
    public String getManufacturer() { 
        return manufacturer;
    }
    public void setManufacturer(String manufacturer) {
        this.manufacturer = manufacturer;
    }
}

public class Airbus extends Plane{
    private String capacity;
    public Airbus() {}
    public String getCapacity() { return capacity; }
    private void setCapacity(String capacity) { 
        this.capacity = capacity; 
    }
}
public class Boeing extends Plane{
    private String comfort;
    public Boeing() {}
    public String getComfort() { return comfort; }
    private void setComfort(String comfort) { 
        this.comfort = comfort; 
    }
}

配置文件:

<hibernate-mapping package="Sample.Entity"
discriminator-value="0“ >
    <class name="Plane" table="planes">
        <id name="id" column="ID">
            <generator class="native"/>
        </id>
        <discriminator column="DISC" type="string"/>
        <property name="type"/>
        <property name="manufacturer"/>
        <subclass name="Airbus" discriminator-value="1">
            <property name="capacity" />
        </subclass>
        <subclass name="Boeing" discriminator-value="2">
            <property name="comfort" />
        </subclass>
    </class>
</hibernate-mapping>

这里写图片描述

优点:效率最高,不需要多表联合查询.
缺点:会产生太多的数据冗余,大量的null字段,导致完整性约束不能在数据库层面上使用,只能依靠数据操作层维持.
3. Joined table

@Entity(name = "Account")
@Inheritance(strategy = InheritanceType.JOINED)
public static class Account {

    @Id
    private Long id;

    private String owner;

    private BigDecimal balance;

    private BigDecimal interestRate;

    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 BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }

    public BigDecimal getInterestRate() {
        return interestRate;
    }

    public void setInterestRate(BigDecimal interestRate) {
        this.interestRate = interestRate;
    }
}

@Entity(name = "DebitAccount")
public static class DebitAccount extends Account {

    private BigDecimal overdraftFee;

    public BigDecimal getOverdraftFee() {
        return overdraftFee;
    }

    public void setOverdraftFee(BigDecimal overdraftFee) {
        this.overdraftFee = overdraftFee;
    }
}

@Entity(name = "CreditAccount")
public static class CreditAccount extends Account {

    private BigDecimal creditLimit;

    public BigDecimal getCreditLimit() {
        return creditLimit;
    }

    public void setCreditLimit(BigDecimal creditLimit) {
        this.creditLimit = creditLimit;
    }
}
CREATE TABLE Account (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    PRIMARY KEY ( id )
)

CREATE TABLE CreditAccount (
    creditLimit NUMERIC(19, 2) ,
    id BIGINT NOT NULL ,
    PRIMARY KEY ( id )
)

CREATE TABLE DebitAccount (
    overdraftFee NUMERIC(19, 2) ,
    id BIGINT NOT NULL ,
    PRIMARY KEY ( id )
)

ALTER TABLE CreditAccount
ADD CONSTRAINT FKihw8h3j1k0w31cnyu7jcl7n7n
FOREIGN KEY (id) REFERENCES Account

ALTER TABLE DebitAccount
ADD CONSTRAINT FKia914478noepymc468kiaivqm
FOREIGN KEY (id) REFERENCES Account

创建了三个表格,子表中只存在子类的自身属性加上父类的外键约束.
因为在查询的时候,语句大约是:

    select ...
    from Account
    ... Join DebitAccount
    ... Join CreditAccount.

这种策略使用join 操作父子类表.
配置文件版本:

public class Cat {
    private Long uid;
    private Date birthday;
    private String color;
    private String sex;
    private int weight;

    public Cat() {
    }

    public Long getUid() {
        return uid;
    }

    private void setUid(Long uid) {
        this.uid = uid;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getWeight() {
        return weight;
    }

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

public class DomesticCat extends Cat {
    private String name;

    public DomesticCat() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

<hibernate-mapping package="Sample.Entity">
<class name="Cat" table="CATS">
    <id name="uid" column="UID">
        <generator class="native"/>
    </id>
    <property name="birthday" type="date"/>
    <property name="color"/>
    <property name="sex"/>
    <property name="weight"/>
    <joined-subclass name="DomesticCat" table="DOMESTIC_CATS">
        <key column="CAT"/>
        <property name="name" type="string"/>
    </joined-subclass>
</class>
</hibernate-mapping>

这里写图片描述
映射到多张表中,但是子表并没有父表的属性,只有一个父表的外键.
优点:减少了数据冗余
缺点:数据量太大是,join操作会影响性能
4. Table per class
每个表一个映射表,注意:此时ID生成策略不能使用generate,需要手动保证子父表之间ID的唯一性,可以考虑使用generateTable方法.

    @Entity(name = "Account")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public static class Account {

    @Id
    private Long id;

    private String owner;

    private BigDecimal balance;

    private BigDecimal interestRate;

    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 BigDecimal getBalance() {
        return balance;
    }

    public void setBalance(BigDecimal balance) {
        this.balance = balance;
    }

    public BigDecimal getInterestRate() {
        return interestRate;
    }

    public void setInterestRate(BigDecimal interestRate) {
        this.interestRate = interestRate;
    }
}

@Entity(name = "DebitAccount")
public static class DebitAccount extends Account {

    private BigDecimal overdraftFee;

    public BigDecimal getOverdraftFee() {
        return overdraftFee;
    }

    public void setOverdraftFee(BigDecimal overdraftFee) {
        this.overdraftFee = overdraftFee;
    }
}

@Entity(name = "CreditAccount")
public static class CreditAccount extends Account {

    private BigDecimal creditLimit;

    public BigDecimal getCreditLimit() {
        return creditLimit;
    }

    public void setCreditLimit(BigDecimal creditLimit) {
        this.creditLimit = creditLimit;
    }
}       

    CREATE TABLE Account (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    PRIMARY KEY ( id )
)

CREATE TABLE CreditAccount (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    creditLimit NUMERIC(19, 2) ,
    PRIMARY KEY ( id )
)

CREATE TABLE DebitAccount (
    id BIGINT NOT NULL ,
    balance NUMERIC(19, 2) ,
    interestRate NUMERIC(19, 2) ,
    owner VARCHAR(255) ,
    overdraftFee NUMERIC(19, 2) ,
    PRIMARY KEY ( id )
)

注意生成了三张表,对应三个类,并且每个类的主键都没有依赖,为了保证每个对象都是有唯一的id,(内存中三个对象id都需要不同)我们需要手动保证三个table的id列都是唯一的,比如说,Account中有一个元组中id为1,那么DebitAccount中就不能有元组id为1.同理,DebitAccount中有id为1,其他两个表也是一样.
查询的时候,三个表之间使用了union查询语句.
配置版本:

    public class Fruit {
    private Long id;
    private String shape;
    private String flavor;
    private String color;

    public Fruit() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getShape() {
        return shape;
    }

    public void setShape(String shape) {
        this.shape = shape;
    }

    public String getFlavor() {
        return flavor;
    }

    public void setFlavor(String flavor) {
        this.flavor = flavor;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

public class Banana extends Fruit{
    private int length;

    public Banana() {
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }
}

public class Apple extends Fruit {
    private int weight;

    public Apple() {
    }

    public int getWeight() {
        return weight;
    }

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

<hibernate-mapping package="entities">
    <class name="entities.Fruit" table="`fruit`">
        <id name="id" column="ID">
            <!--table per class 策略不能使用 generate 策略,否则无法生成sessionFactory.可以考虑使用generateTable-->
        </id>
        <property name="shape"/>
        <property name="flavor"/>
        <property name="color"/>
        <union-subclass name="Apple" table="`apple`">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="entities.Banana" table="`banana`">
            <property name="length"/>
        </union-subclass>
    </class>
</hibernate-mapping>

这里写图片描述

好了,至此,内存中的对象与数据库元组之间的继承关系和关联关系已经下完了.

贴上课上PPT

Hibernate使用注解，继承映射写法
focusぃclouds
08-19 5526
继承映射在 Annotation 中使用 @Inheritance 注解，并且需要使用 strategy 属性指定继承策略，继承策略有 SINGLE_TABLE、TABLE_PER_CLASS 和 JOINED 三种。 一、SINGLE_TABLE SINGLE_TABLE 是将父类和其所有的子类集合在一块，存在一张表中，并创建一个新的字段来判断对象的类型。 Person.j
hibernate实现继承
wzff2154的专栏
05-23 1505
1.hibernate中子类继承的表实现 三种策略: 一个表:优点......需要多态,子类属性比较少的时候实用.        缺点......有空字段.需要标志位. 二张表:优点......没有多态时候,操作针对单表,不需要映射查询的时候很实用.简单易用.        缺点......父类信息在子类分别体现,浪费.修改父类的时候子类信息所这被修改. 三张表:优点......充分体现多态,修改
让Hibernate同时支持xml和注解两种映射方式
10-18
让Hibernate同时支持xml和注解两种映射方式
Hibernate继承映射
alva88888888的博客
01-26 197
Hibernate继承映射 　　在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。...
Hibernate继承映射详解
鹏霄万里展雄飞
02-21 2444
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继承体系下
hibernate继承映射详解
u010793590的专栏
06-06 831
•Hibernate支持三种继承映射策略： –每个具体类一张表(tableper concrete class) 将域模型中的每一个实体对象映射到一个独立的表中，也就是说不用在关系开数据模型中考虑域模型中的继承关系和多态。 –每个类分层结构一张表(tableper class hierarchy) 对于继承关系中的子类使用同一个表，这就需要在数据库表中增加额外的区分子类类型的字段。
hibernate注解处理映射关系共14页.pdf.zip
10-29
2. **注解基础**：在Hibernate 3.2版本之后，引入了注解支持，使得无需XML配置文件，开发者可以直接在类和属性上使用注解来定义映射规则。常见的注解包括@Entity、@Table、@Id、@GeneratedValue等。 3. **实体类...
Hibernate注解映射关系详解教程
Hibernate是一个流行的Java ORM（对象关系映射）框架，它允许开发者通过注解或XML文件的方式，将Java对象映射到关系数据库中，从而简化数据持久化的操作。文档共14页，对使用注解的方式来处理Java实体与数据库表之间...
spring整合struts2与hibernate核心配置文件
07-05
整合SSH涉及到的主要配置文件有`struts2-spring-plugin.xml`、`spring-context.xml`以及Hibernate的相关配置文件（如`hibernate.cfg.xml`）。`struts2-spring-plugin.xml`配置Struts2与Spring的集成，确保Action类由...
SpringBoot整合Hibernate纯注解版
03-25
以上就是Spring Boot整合Hibernate纯注解版的基本配置和使用。通过这种方式，开发者可以专注于业务逻辑，而不必关心繁琐的数据访问层实现。此外，Spring Boot的自动配置和Hibernate的注解方式，使得整个项目结构更加...
spring mvc+hibernate 实现事务管理（全注解版）
08-28
3. **全注解配置**: 使用全注解配置可以避免XML配置文件，使得项目更简洁。在Spring MVC中，我们可以通过@Configuration和@EnableWebMvc注解定义配置类，并使用@Bean注解声明bean。对于Hibernate，我们可以使用@...
用Hibernate映射继承关系
11-19
讲解了Hibernate的关联映射包括一对一，一对多，多对多
hibernate映射继承关系（每个类都对应一张表）
11-28
hibernate实现继承关系映射的方式有三种，这种方式是将每个类都映射成一张表。
Hibernate继承
HotSunMoon的专栏
08-17 448
每棵类继承树一张表 因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中， 必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段， 用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤： 父类用普通的标签定义 在父类中定义一个discriminator，即指定这个区分的字段的名称和类型 如： 子类使用标签定义，在定义subcla
Hibernate 继承
bluethirdbank的博客
11-29 222
  在域模型中，类与类之间除了关联关系和聚集关系，还可以存在继承关系，在下图所示的域模型中，Deparment类和Employee类之间为一对多的 双向关联关系，Employee类有两个子 类：Skiller类和Sales类。由于Java只允许一个类最多有一个直接的父类，因此Employee类、 Skiller类和Sales类构成了一棵继承关系树。 在 面向对象的范畴中，还存在多态的概念，多态建...
Hibernate继承关系
05-14 144
1、整个继承树映射到一张表 在一个论坛中有用户（User）这个实体类，其中User这个实体中有分为普通用户，管理员与游客这3种身份，而这3种现在身份的用户就只有一个字段（即类型）不相同，可以考虑用Hibernate中的Table per class hierarchy策略   对象模型(Java类结构) 表结构 User代码: package org.hibernate.domain...
学习hibernate（六） -- hibernate继承
weixin_34148340的博客
04-07 155
2019独角兽企业重金招聘Python工程师标准>>> ...
Hibernate多层继承配置
走过的足迹
01-19 1580
1、对象模型图 2、表结构、对象结构及其对应关系 3、映射文件配置 【配置说明】 a、分别为继承体系中的各个类定义持久类，其中只有父类（继承体系中最顶层的类）包含标识符属性（即主键）！ b、子类继承父类，子类声明个性化字段，切记不用再声明主键字段！！！ c、继承体系中的各个类分别映射到不同的表，父表与子表通过外键关联（主键也是外键
Hibernate 继承关系配置
萧若寒
11-16 8361
第一种情况：Hibernate 继承关系每个子类一张表 Person.java package com.wansha.pojo; public class Person { private int id; private String name; public int getId() { return id; } public void setId(int id
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值