Hibernate 继承关系的映射
博客专区 > ruyees 的博客 > 博客详情
Hibernate 继承关系的映射
ruyees 发表于4年前
Hibernate 继承关系的映射
  • 发表于 4年前
  • 阅读 14
  • 收藏 0
  • 点赞 0
  • 评论 0

移动开发云端新模式探索实践 >>>   

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 .net
  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 3
博文 71
码字总数 0
×
ruyees
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: