Hibernate 继承关系的映射

csdn_zuoqiang

浏览: 845720 次
性别:
来自: 深圳

最近访客更多访客>>

wrgjwrrjurhj

qijojo

game438951

arpenker

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

hibernate

Hibernate .net

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">

</id>

</class>

</id>

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

</class>

</id>

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

</class>

</hibernate-mapping>

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

基类（根类）对应一个表

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

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

</id>

</class>

</id>

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

</subclass>

</subclass>

</class>

</hibernate-mapping>

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

每个类对应一个表

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

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

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

</id>

</class>

</id>

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

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

</subclass>

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

</subclass>

</class>

</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]

分享到：

18位身份证验证小组件 | JAVA基础－其全面详解Java基础知识

2010-08-04 18:38
浏览 1032
评论(0)
分类:企业架构
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论