`

Hibernate 继承关系的映射

阅读更多

Hibernate 中支持的 3种类型的继承关系:

1,表与子类之间的独立的一对一关系

2,每个子类对应一张子表,并与主类共享主表

3,表与类的一对多关系

 

1,表与子类之间的独立的一对一关系

这种情况 是最普通的一个类对应一个表,就不在举例。

 

2,每个子类对应一张子表 并与主类共享主表

实质:通过调用子类操作自己表和父类的表利用xml文件中joined-subclass节点

 

具体实例:

 

package extend.hibernate;

public class Titem implements java.io.Serializable {

private int pids;
private String pname;

public Titem() {
}

public Titem(int pids) {
   this.pids = pids;
}

public Titem(int pids, String pname) {
   this.pids = pids;
   this.pname = pname;
}

public int getPids() {
   return this.pids;
}

public void setPids(int pids) {
   this.pids = pids;
}

public String getPname() {
   return this.pname;
}

public void setPname(String pname) {
   this.pname = pname;
}

}
package extend.hibernate;

public class TDvd extends Titem {
private String version;

public String getVersion() {
   return version;
}

public void setVersion(String version) {
   this.version = version;
}

}

 

package extend.hibernate;

public class TBook extends Titem {
private int pages;

public int getPages() {
   return pages;
}

public void setPages(int pages) {
   this.pages = pages;
}

}

 

 

3,表与类的一对多关系

实质: 是通过数据库中的一个字段来区分 (在映射文件种配置,无须在程序种写出)调用那个类,利用的是映射文件的discriminator(鉴别器) subclass节点。

 

具体实例:

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="one.hibernate.Item" table="ITEM" schema="SALES">
   <id name="itemid" type="java.lang.Integer">
    <column name="ITEMID" precision="22" scale="0" />
    <generator class="assigned" />
   </id>
  <discriminator column="dif" type="java.lang.String" />
   <property name="itemname" type="java.lang.String">
    <column name="ITEMNAME" length="20" />
   </property>
   <subclass name="one.hibernate.TBook" discriminator-value="1">
   <property name="pages" type="java.lang.Integer">
     <column name="PAGES" precision="22" scale="0" />
    </property>
   </subclass>
   <subclass name="one.hibernate.TDvd" discriminator-value="2">
   <property name="version" type="java.lang.String">
     <column name="VERSION" length="20" />
    </property>
   </subclass>
</class>
</hibernate-mapping>

 

类的关系:

package one.hibernate;

public class Item implements java.io.Serializable {
private int itemid;
private String itemname;
public Item() {
}
public Item(int itemid) {
   this.itemid = itemid;

}
public Item(int itemid, String itemname) {
   this.itemid = itemid;

   this.itemname = itemname;

}

public int getItemid() {
   return this.itemid;
}

public void setItemid(int itemid) {
   this.itemid = itemid;
}

public String getItemname() {
   return this.itemname;
}

public void setItemname(String itemname) {
   this.itemname = itemname;
}

}

 

package one.hibernate;

public class TBook extends Item {
private int pages;

public int getPages() {
   return pages;
}

public void setPages(int pages) {
   this.pages = pages;
}

}

 

package one.hibernate;

public class TDvd extends Item {
private String version;

public String getVersion() {
   return version;
}

public void setVersion(String version) {
   this.version = version;
}

}

 

--------------------------------------------------------------------------------------------------------------------------------

 

Hibernate 继承关系的映射

 

Java.Net类与类之间存在关联、聚集和继承关系。一般来说:

关联关系:采用“一对多或一对一”的映射即可;

聚集关系:采用“集合映射”,即映射Set,Bag,List,Map

继承关系:

因为关系数据库的表之间不存在继承关系,所以Hibernate提供了以下三种对继承关系映射的方法,即在继承关系树中:

(1)、每个具体类(非抽象类)对应一个表:此方式中关系数据模型完全不支持对象的继承关系。

(2)、基类(根类)对应一个表:此方式中对关系数据模型进行非常规设计,在数据库表中加入额外的区分子类的字段,从而使关系数据模型可以支持继承关系。

(3)、每个类对应一个表:此方式中在关系数据模型中用外键关系来表示继承关系。

这三种映射方式都各自有利有弊,需要根据具体情况来选择使用。分别说明一下:

为了说明方便,引用一个比较经典的简单例子

Employee类,它为抽象类,有两个直接子类

HourlyEmployee类,Employee的子类,继承父类的name属性

SalarilyEmployee类,Employee的子类,继承父类的name属性

Company类,它有一个employees集合属性

 

继承关系中每个具体类对应一个表

这是最简单的映射方式。基类Employee没用映射,只需要为两个子类提供映射关系即可。看一下映射文件:

<hibernate-mapping package="com.wjb.mypack">

    <!--Company的映射-->

    <class name="Company" table="COMPANIES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" type="string" column="NAME"/>

    </class>

    <!--HourlyEmployee的映射-->

    <class name="HouredEmployee" table="HOURLY_EMPLOYEES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <!--映射从父类继承的name属性-->

        <property name="name" type="string" column="NAME"/>

        <property name="rate" type="double" column="RATE"/>

        <many-to-one name="company" column="COMPANY_ID" class="Company"/>

    </class>

    <!--SalarilyEmployee的映射-->

    <class name="SalarilyEmployee" table="SALARILY_EMPLOYEES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <!--映射从父类继承的name属性-->

        <property name="name" type="string" column="NAME"/>

        <property name="salary" type="double" column="SALARY"/>

        <many-to-one name="company" column="COMPANY_ID" class="Company"/>

    </class>

    <!--注:Employee类没有映射,在DB中不存在对应的表-->

</hibernate-mapping>

可以看出,在这种映射方式中,每个子类除了映射自己的属性外,还需要映射从父类继承来下的属性,这是该映射方式的一个特点。

 

基类(根类)对应一个表

这种映射方式只需为基类Employee创建一个表即可。在表中不仅提供与Employee所有属性的字段,还要提供与所有子类属性对应的字段,此外还需要一个字段用于区分子类的具体类型。此时的映射文件为:

<hibernate-mapping package="com.wjb.mypack">

    <!--Company的映射-->

    <class name="Company" table="COMPANIES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" type="string" column="NAME"/>

    </class>

    <!--Employee以及子类的映射-->

    <class name="Employee" table="EMPLOYEES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <!--用于区分子类类型的字段-->

        <discriminator type="string" column="EMPLOYEE_TYPE">

        <property name="name" type="string" column="NAME"/>

        <many-to-one name="company" column="COMPANY_ID" class="Company"/>

        <!--子类HourlyEmployee的映射-->

        <subclass name="HourlyEmployee" discriminator-value="HE">

            <property name="rate" column="RATE" type="double"/>

        </subclass>

        <!--子类SalarilyEmployee的映射-->

        <subclass name="SalarilyEmployee" discriminator-value="SE">

            <property name="salary" column="SALARY" type="double"/>

        </subclass>

    </class>

    <!--注:HourlyEmployee类没有单独的映射,在DB中不存在对应的表-->

    <!--注:SalarilyEmployee类没有单独的映射,在DB中不存在对应的表-->

</hibernate-mapping>

可以看出,每个子类没有单独的映射,在DB中没有对应的表存在。而只有一个记录所有自身属性和子类所有属性的表,在子类为HourlyEmployee的时候,SALARY字段将为NULL,同样子类为SalarilyEmployee的时候,RATE字段将为NULL。那么,如果业务逻辑要求SalariedEmployee对象的rate属性不允许为null,显然无法在EMPLOYEES表中为SALARY字段定义not null约束,可见这种映射方式无法保证关系数据模型的数据完整性。

 

每个类对应一个表

这种方式为基类和子类分别创建表,即EMPLOYEESHESE三个表。EMPLOYEES只包含Employee自己属性的字段,每个子类的表也同样只包含自己类属性的字段。此外,HE表和SE表都以EMPLOYEE_ID字段作为主键,该字段还同时作为外键参照EMPLOYEES表。

HourlyEmployeeSalarilyEmployee没有独立的映射配置,但是在DB中有相应的表存在,这是其一个特点。

<hibernate-mapping package="com.wjb.mypack">

    <!--Company的映射-->

    <class name="Company" table="COMPANIES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" type="string" column="NAME"/>

    </class>

    <!--Employee以及子类的映射-->

    <class name="Employee" table="EMPLOYEES">

        <id name="id" type="long" column="ID">

            <generator class="native"/>

        </id>

        <property name="name" type="string" column="NAME"/>

        <many-to-one name="company" column="COMPANY_ID" class="Company"/>

        <!--子类HourlyEmployee的映射-->

        <joined-subclass name="HourlyEmployee" table="HE">

            <key column="EMPLOYEE_ID"/>

            <property name="rate" column="RATE" type="double"/>

        </subclass>

        <!--子类SalarilyEmployee的映射-->

        <joined-subclass name="SalarilyEmployee" table="SE">

            <key column="EMPLOYEE_ID"/>

            <property name="salary" column="SALARY" type="double"/>

        </subclass>

    </class>

    <!--注:HourlyEmployee类没有单独的映射,但在DB中有对应的表-->

    <!--注:SalarilyEmployee类没有单独的映射,但在DB中有对应的表-->

</hibernate-mapping>

可见,两个<joined-subclass>元素用于映射两个子类,<joined-subclass>元素的<key>子元素指定HE表和SE表中既作为主键又作为外键的EMPLOYEE_ID字段。

 

三种映射方式的比较和选择:

为了方便说明为三种方式按顺序标号为[1][2][3]

1、复杂度:

    [1]包含重复字段;

    [2]简单;

    [3]表较多且之间有外键约束;

2、查询性能:

    [1]若查询父类需查所有子类表;

    [2]效率高;

    [3]需要表内连接或左外连接;

3、可维护性:

    [1]若父类属性变化需要修改所有子类对应的表;

    [2]只需修改一个表;

    [3]若某个类属性变化只修改这个类对应的表;

综上,选择时,可以参考以下原则:

1、子类属性不是非常多时,优先考虑[2],因为其性能最佳。

2、子类属性非常多,且对性能要求不是很严格时,优先考虑[3]

 

分享到:
评论

相关推荐

    Hibernate继承关系映射.pdf

    标题:“Hibernate继承关系映射.pdf” 描述:“简明扼要地介绍了Hibernate中继承关系的映射方式,深入探讨了三种不同的映射策略及其优缺点,同时解析了多态查询的概念。” 知识点: ### Hibernate继承关系映射...

    Hibernate继承映射代码

    本主题将深入探讨"Hibernate继承映射+C3P0代码"的相关知识点。 首先,让我们理解Hibernate的继承映射。在Java中,我们可以创建一个基类,然后派生出多个子类,这种设计模式在数据库中也可以被映射出来。Hibernate...

    用Hibernate映射继承关系

    映射文件应定义该类的属性与数据库表中的列之间的映射关系。例如,对于`HourlyEmployee`类,映射文件可能如下所示: ```xml ``` 类似的,`SalariedEmployee`类也有其对应的映射文件。 ##### 14.1.2 ...

    hibernate继承映射.rar

    Hibernate继承映射是将Java中的继承关系映射到数据库的关系模型中。在Java中,一个基类可以有多个子类,而在数据库中,这些子类可以共享一张表或者各自拥有独立的表,这取决于我们选择的继承策略。Hibernate提供了四...

    hibernate的继承映射关系

    ### Hibernate的继承多态映射关系详解 在软件开发领域,特别是使用面向对象编程语言如Java进行开发时,我们经常需要处理复杂的类继承关系。在ORM(Object-Relational Mapping)框架如Hibernate中,如何优雅地将这些...

    Hibernate继承映射的第一种策略:每棵类继承树对应一张表

    Hibernate继承映射是将Java类的继承关系映射到数据库表的一种策略,使得对象模型的复杂性能够平滑地转化为关系数据库模型。本篇将详细介绍Hibernate继承映射的第一种策略——每棵类继承树对应一张表,即单一表继承...

    hibernate映射继承关系(每个类都对应一张表)

    总结起来,"每个类都对应一张表"的继承映射策略在Hibernate中是一种直接且易于理解的方法,适合那些每个类都有独特属性的情况。然而,它可能不适合所有场景,特别是当子类众多或者需要减少数据冗余时。在实际应用中...

    Hibernate继承映射

    Hibernate的继承映射 --每个继承层次一张表 -- 每个具体类一张表 -- 每个类一张表

    Hibernate继承映射-概述

    《Hibernate继承映射详解》 在Java开发中,对象关系映射(ORM)框架如Hibernate大大简化了数据库操作。Hibernate不仅提供了对基本数据类型的映射,还支持复杂的数据结构,如继承关系的映射。本篇文章将深入探讨...

    Hibernate继承映射(annotation)

    **标题:“Hibernate继承映射(Annotation)详解”** 在Java持久化框架Hibernate中,继承映射是一种关键特性,它允许开发者将对象模型的继承结构映射到数据库的表结构。在传统的面向对象编程中,继承是实现代码复用和...

    hibernate继承映射教学

    针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...

    hibernate的继承映射教学

    针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...

    Hibernate继承映射二:每个子类一张表

    总结来说,“每个子类一张表”的继承映射策略是Hibernate提供的一种处理继承关系的方法,它将类的继承结构映射到数据库的多个表中。这种策略适合于子类具有大量特有属性的情况,但需要权衡可能带来的数据库设计复杂...

Global site tag (gtag.js) - Google Analytics