hibernate 映射继承关系

最新推荐文章于 2020-06-29 09:48:30 发布
最新推荐文章于 2020-06-29 09:48:30 发布
阅读量871 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongecs/article/details/51362593
版权

实现方式一般有三种：
1. 继承关系树每个具体类对应一张表（不介绍）
2. 继承关系树的根类对应一张表
3. 继承关系树的每个类对应一张表

先介绍关系：
DayEmployee和MonthEmploy是Employee的子类，并且Company和Employee是一对多关系：

具体代码如下：

Company.java

import java.util.HashSet;
import java.util.Set;

public class Company {
    private Integer id;
    private String name;
    private Set<Employee> employees = new HashSet<Employee>();

    public Company() {
        super();
    }
    public Company(String name) {
        super();
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Employee> getEmployees() {
        return employees;
    }
    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}

Employee.java

    public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private Company company;
    public Company getCompany() {
        return company;
    }
    public void setCompany(Company company) {
        this.company = company;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

}

DayEmployee.java

public class DayEmployee extends Employee{
    private Double dayMoney;

    public Double getDayMoney() {
        return dayMoney;
    }
    public void setDayMoney(Double dayMoney) {
        this.dayMoney = dayMoney;
    }

}

MonthEmploy.java

    public class MonthEmploy extends Employee{
    private Double monthMoney;

    public Double getMonthMoney() {
        return monthMoney;
    }
    public void setMonthMoney(Double monthMoney) {
        this.monthMoney = monthMoney;
    }

}

Company.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.dongecs.test1.pojo">
    <class name="Company" table="COMPANY">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <set name="employees" table="EMPLOYEE" inverse="true" lazy="true">
            <key>
                <column name="COMPANY" />
            </key>
            <one-to-many class="Employee" />
        </set>
    </class>
</hibernate-mapping>

继承关系树的根类对应一张表对应的Employee.hbm.xml的写法

Employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.dongecs.test1.pojo">
    <!-- 利用discriminator-value默认 empType 的值为emp -->
    <class name="Employee" table="EMPLOYEE" discriminator-value="emp">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
       <!--用于识别此类的类别 -->
        <discriminator column="empType" type="string"/>

        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="java.lang.Integer">
            <column name="AGE" />
        </property>
        <many-to-one name="company" class="Company" fetch="join">
            <column name="COMPANY" />
        </many-to-one>
       <!--  若为DayEmployee，那么将empType的值设为DE -->
        <subclass name="DayEmployee" discriminator-value="DE">
            <property name="dayMoney" type="double"></property>
        </subclass>
         <!--  若为MonthEmploy，那么将empType的值设为ME -->
        <subclass name="MonthEmploy" discriminator-value="ME">
            <property name="monthMoney" type="double"></property>
        </subclass>
    </class>
</hibernate-mapping>

利用上述代码作如下测试：

public class EmployeeTest {

    SessionFactory sessionFactory = null;
    Session session = null;
    Transaction transaction = null;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void after() {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

    @Test
    public void testEmployee() {
        Company company = new Company("com1");

        DayEmployee d1 = new DayEmployee();
        d1.setAge(22);
        d1.setDayMoney(50.0);
        d1.setName("d1");

        MonthEmploy d2 = new MonthEmploy();
        d2.setAge(30);
        d2.setMonthMoney(79.0);
        d2.setName("d2");

        Employee employee = new Employee();
        employee.setAge(90);
        employee.setName("employee");

        d1.setCompany(company);
        d2.setCompany(company);
        employee.setCompany(company);

        //inverse = true 时可以关联， 当相对多出3条update,因此建议使用多的一端关联
//      company.getEmployees().add(employee);
//      company.getEmployees().add(d1);
//      company.getEmployees().add(d2);

        //把一的一段放到最前保存，可以减小3条更新操作
        session.save(company);

        session.save(employee);
        session.save(d2);
        session.save(d1);
    }
}

会得出如下结果：
这里写图片描述

继承关系树的每个类对应一张表Employee.hbm.xml的写法

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.dongecs.test1.pojo">
    <class name="Employee" table="EMPLOYEE">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>

        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="java.lang.Integer">
            <column name="AGE" />
        </property>
        <many-to-one name="company" class="Company" fetch="join">
            <column name="COMPANY" />
        </many-to-one>
        <!--   利用joined-subclass表签外键关联MonthEmploy -->
        <joined-subclass name="MonthEmploy" table="MONEMPLOY">
            <key column="EMPLOYEE_ID"></key>
            <property name="monthMoney" type="double"></property>
        </joined-subclass>
        <joined-subclass name="DayEmployee" table="DAYEMPLOY">
            <key column="EMPLOYEE_ID"></key>
            <property name="dayMoney" type="double"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

测试代码：

public class EmployeeTest {

    SessionFactory sessionFactory = null;
    Session session = null;
    Transaction transaction = null;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                .buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    @After
    public void after() {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }

    @Test
    public void testEmployee() {
        Company company = new Company("com1");

        DayEmployee d1 = new DayEmployee();
        d1.setAge(22);
        d1.setDayMoney(50.0);
        d1.setName("d1");

        MonthEmploy d2 = new MonthEmploy();
        d2.setAge(30);
        d2.setMonthMoney(79.0);
        d2.setName("d2");

        Employee employee = new Employee();
        employee.setAge(90);
        employee.setName("employee");

        d1.setCompany(company);
        d2.setCompany(company);
        employee.setCompany(company);

        //inverse = true 时可以关联， 当相对多出3条update,因此建议使用多的一端关联
//      company.getEmployees().add(employee);
//      company.getEmployees().add(d1);
//      company.getEmployees().add(d2);

        //把一的一段放到最前保存，可以减小3条更新操作
        session.save(company);

        session.save(employee);
        session.save(d2);
        session.save(d1);
    }

    @Test
    public void findFromEmployeeTable(){
        String hql = "from Employee";
        //通过左外链接找
        List<Employee> list = session.createQuery(hql).list();
        for (Employee emp : list){
            if (emp instanceof DayEmployee){
                System.out.println("day");
            } else if (emp instanceof MonthEmploy){
                System.out.println("mon");
            } else {
                System.out.println("emp");
            }
        }
    }

    @Test
    public void findFromDayEmployeeTable(){
        String hql = "from DayEmployee";
        //通过内连接找
        List<Employee> list = session.createQuery(hql).list();
        System.out.println(list.size());
    }
}

得出如下结果：
这里写图片描述
这里写图片描述

结论：

1.使用根类对应一张表
好处：只需创建一张表，不用外键关联
缺点：如果子类属性多，会导致另一子类有过多的空值，而且不能设置一些字段的not null约束,因此不能保证数据库的完整性
2.每个类对应一张表（外键关联）
好处：如果某个类的属性发生变化，只需修改和这个类对应的表
缺点：利用外键关联查询

ref:

孙卫琴.精通Hibernate：Java对象持久化技术详解

dongecs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate中的Entity类之间的继承关系之二SINGLE_TABLE
成长的足迹
06-06 4220
为了解决Entity类的继承与关系数据库表的对应不匹配问题，Hibernate提供了4种兼容JPA的策略，这里介绍第二种Single table。 在这种策略中，存在如下特征： 数据库中只有一个表，其中包含了继承相关的所有父子Entity类的属性父Entity中有一个特殊的属性作为区分标识 1.Single table策略的实现 父Entity类定义如下： @Enti
Hibernate继承映射
alva88888888的博客
01-26 144
Hibernate继承映射 　　在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。...
[转载]Hibernate的继承关系
congji3817的博客
05-21 85
Hibernate的继承关系一、每个子类对应一个数据表(Table per concrete class) 学生表 create table `sample`.`student`( `id` bigint n...
Hibernate的4种继承关系
不积跬步 无以至千里 不积小流 无以成江海
06-05 273
一、继承关系_整个继承树映射到一张表 对象模型(Java类结构) 一个类继承体系一张表(subclass)(表结构) Employee.java package com.taobao.hibernate.domain; public class Employee { private int id; private String name; private Depart...
hibernate——继承关系以及三个subclass标签的区别
热门推荐
成长的足迹
11-30 1万+
Java类中有继承关系，相应的在hibernate中，也有继承关系，子类反应到数据库中，就有多种实现形式了，子类和父类可以映射到同一张表中，子类也可以单独映射成一张表，但是用不同的标签实现，子类表和父类表的关系也不同。在映射文件中，有三个标签可以实现继承关系，分别是：subclass、joined-subclass、union-subclass，先陈述一下这三个标签的区别： subclass标签
JPA和Hibernate中的继承关系
cxu0262的博客
06-29 152
继承是面向对象编程中的一种常见模式，但它不容易在数据库中复制。 这个Java技巧向您展示了如何使用Hibernate在JPA中对继承关系进行建模。 了解四种不同的ORM继承策略的优缺点，并获得选择最能满足您的应用程序需求的技巧。 我假设您已经通过JPA和Hibernate入门了Java持久性，包括如何建模实体和关系以及如何使用JPA的EntityManager 。 如果您不熟悉这些概...
Hibernate映射继承关系的三种方案.docx
06-19
那么，这种继承关系在hibernate是如何映射呢？ 对于面向对象的程序设计语言而言，继承和多态是两个最基本的概念。hibernate的集成映射可以理解为持久化类之间的继承关系。在上边的例子中，学生集成了人，可以认为...
精通Hibernate之映射继承关系（三）
02-22
这种映射方式只需为继承关系树的Employee根类创建一张表EMPLOYEES。如图14-4所示，在EMPLOYEES表中不仅提供和Employee类的属性对应的字段，还要提供和它的两个子类的所有属型对应的字段，此外，EMPLOYEES表中需要...
用Hibernate映射继承关系
05-26
用Hibernate映射继承关系
精通Hibernate之映射继承关系（六）
02-04
Company与Employee类之间为一对多多态关联关系，如果继承关系树的根类对应一个表，或者每个类对应一个表，那么就能映射Company类的employees集合。本节介绍如何映射多对一多态关联。如图14-11所示，ClassD与ClassA为...
Hibernate继承映射详解
鹏霄万里展雄飞
02-21 2356
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表表示所有继承体系下
Java程序员从笨鸟到菜鸟之（五十五）细谈Hibernate（六）Hibernate继承关系映射
05-25 59
在面向对象的程序领域中，类与类之间是有继承关系的，例如Java世界中只需要extends关键字就可以确定这两个类的父子关系，但是在关系数据库的世界 中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据 中，Hibernate为我们提供了3中方案： 第一种方案：一个子类对应一张表。 第二种方案：使用一张表...
(8)hibernate四种继承映射
jianfpeng241241的专栏
11-20 939
一 一个类继承体系一张表 二 每个子类不同的部分用一张表 三 继承关系与内连接结合 四 每个具体类一张表
hibernate继承关系映射方法（三）--每个具体类一张表TPC
tuke_tuke的博客
11-28 2522
TPC:所谓是“每个具体类一张表(table per concrete class)”的意思是:使继承体系中每一个子类都对应数据库中的一张表。每一个子类对应的数据库表都包含了父类的信息，并且包含了自己独有的属性。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段。这种策略是使用标签来定义子类的。 注意：三个类+一个父类映射文件+两张表 st
hibernate继承关系映射
yanwushu的博客
06-20 3202
在问题域中实体之间的继承关系在数据库中有多种体现方式。在hibernate中，要实现面向对象的对实体进行持久化操作，那么就需要对实体类进行继承关系映射。 根据数据表的不同形态，映射方案有三种 实体继承关系模型： 1.Tpc每个具体类一张表 mysql> show tables; +-------------------+ | Tabl
【HIbernate框架学习】：Hibernate对象继承关系映射（一）
life is wonderful
12-12 1036
继承关系映射实现的三种策略：        单表继承：每棵类继承树使用一个表(table per class hierarchy) ，也就是一棵继承树映射一张表。        具体表继承：每个子类一个表(table per subclass)，也就是每个子类各自映射表。        类表继承：每个具体类一个表(table per concrete class)（有一些限制），也就是继承树
hibernate继承关系映射方法(一)--共享一张表
tuke_tuke的博客
11-22 2590
对于如下关系： Person.java package com.hust.PO; public class Person { private Integer id; private String name; private Integer age; private String sex; public Integer getId() {
hibernate继承关系映射关系方法（二）--每个子类一张表
tuke_tuke的博客
11-28 3113
TPS:所谓“每个子类一张表（Table Per Subclass）”：父类一张表，每个子类一张表，父类的表保存公共有信息，子类的表只保存自己特有的信息      这种策略是使用标签来定义子类的。父类、子类都对应一张数据库表。在父类对应的数据库表中，它存储了所 有记录的公共信息，实际上该父类对应的表会包含所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映
hibernate的继承关系
hwt_211博客
05-10 351
继承关系： 对于pojo类，Employee中放所有员工的相同属性，不同的子类就只放子类的特有属性，子类再继承父类 如：                    Employee (员工表)     Seller（员工中的销售人员）                Skiller(员工中的技术人员) 对于继承关系分为四种情况： 1，当子类中的特有属性很少，可以直接建立在
SpringBoot集成Hibernate
最新发布
07-28
3. 定义实体类：创建与数据库表对应的实体类，并使用注解来定义实体类与表的映射关系。例如： ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值