第10 章继承映射(InheritanceMappings)
10.1. 三种策略
Hibernate支持三种基本的继承映射策略：
・每个类分层结构一张表(table per class hierarchy)
・每个子类一张表(table per subclass)
・每个具体类一张表(table per concrete class)
此外，Hibernate还支持第四种稍有不同的多态映射策略：
・隐式多态(implicitpolymorphism)
对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多态来完成跨越整个层次的多态。但是在同一个<class>根元素 下，Hibernate不支持混合了元素<subclass>、 <joined-subclass>和<union-subclass>的映射。在同一个<class>元素下，可以混合使用“每个类分层结构一张表”（table per hierarchy） 和“每个子类一张表”（table per subclass） 这两种映射策略，这是通过结合元素<subclass>和 <join>来实现的（见后）。
10.1.1. 每个类分层结构一张表(Table per class hierarchy)
假设我们有接口Payment和它的几个实现类： CreditCardPayment, CashPayment, 和ChequePayment。则“每个类分层结构一张表”(Table per class hierarchy)的映射代码如下所示：
<class name="Payment" table="PAYMENT">
<id name="id"type="long" column="PAYMENT_ID">
<generatorclass="native"/>
</id>
<discriminatorcolumn="PAYMENT_TYPE" type="string"/>
<propertyname="amount" column="AMOUNT"/>
...
<subclassname="CreditCardPayment" discriminator-value="CREDIT">
<propertyname="creditCardType" column="CCTYPE"/>
...
</subclass>
<subclassname="CashPayment" discriminator-value="CASH">
...
</subclass>
<subclassname="ChequePayment" discriminator-value="CHEQUE">
...
</subclass>
</class>
采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段，如CCTYPE，不能有非空(NOT NULL)约束。
10.1.2. 每个子类一张表(Table per subclass)
对于上例中的几个类而言，采用“每个子类一张表”的映射策略，代码如下所示：
<class name="Payment" table="PAYMENT">
<id name="id"type="long" column="PAYMENT_ID">
<generatorclass="native"/>
</id>
<propertyname="amount" column="AMOUNT"/>
...
<joined-subclassname="CreditCardPayment" table="CREDIT_PAYMENT">
<keycolumn="PAYMENT_ID"/>
...
</joined-subclass>
<joined-subclassname="CashPayment" table="CASH_PAYMENT">
<keycolumn="PAYMENT_ID"/>
<propertyname="creditCardType" column="CCTYPE"/>
...
</joined-subclass>
<joined-subclassname="ChequePayment" table="CHEQUE_PAYMENT">
<keycolumn="PAYMENT_ID"/>
...
</joined-subclass>
</class>
需要四张表。三个子类表通过主键关联到超类表(因而关系模型实际上是一对一关联)。
10.1.3. 每个子类一张表(Table per subclass)，使用辨别标志(Discriminator)
注意，对“每个子类一张表”的映射策略，Hibernate的实现不需要辨别字段，而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类 表中有一个类型辨别字段(type discriminatorcolumn)。Hibernate采用的方法更 难实现，但从关系（数据库）这点上来看，按理说它更正确。若你愿意使用带有辨别字段的“每个子类一张表”的策略，你可以结合使用<subclass>与<join>，如下所示：
<class name="Payment" table="PAYMENT">
<id name="id"type="long" column="PAYMENT_ID">
<generatorclass="native"/>
</id>
<discriminatorcolumn="PAYMENT_TYPE" type="string"/>
<propertyname="amount" column="AMOUNT"/>
...
<subclassname="CreditCardPayment" discriminator-value="CREDIT">
<jointable="CREDIT_PAYMENT">
<property name="creditCardType"column="CCTYPE"/>
...
</join>
</subclass>
<subclassname="CashPayment" discriminator-value="CASH">
<jointable="CASH_PAYMENT">
...
</join>
</subclass>
<subclassname="ChequePayment" discriminator-value="CHEQUE">
<jointable="CHEQUE_PAYMENT" fetch="select">
...
</join>
</subclass>
</class>
可选的声明fetch="select"，是用来告诉Hibernate，在查询超类时， 不要使用外部连接(outerjoin)来抓取子类ChequePayment的数据。
10.1.4. 混合使用“每个类分层结构一张表”和“每个子类一张表”
你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略：
<class name="Payment" table="PAYMENT">
<id name="id"type="long" column="PAYMENT_ID">
<generator/>
</id>
<discriminatorcolumn="PAYMENT_TYPE" type="string"/>
<propertyname="amount" column="AMOUNT"/>
...
<subclassname="CreditCardPayment" discriminator-value="CREDIT">
<jointable="CREDIT_PAYMENT">
<propertyname="creditCardType" column="CCTYPE"/>
...
</join>
</subclass>
<subclassname="CashPayment" discriminator-value="CASH">
...
</subclass>
<subclassname="ChequePayment" discriminator-value="CHEQUE">
...
</subclass>
</class>
对上述任何一种映射策略而言，指向根类Payment的 关联是使用<many-to-one>进行映射的。
<many-to-one name="payment" column="PAYMENT_ID"class="Payment"/>
10.1.5. 每个具体类一张表(Table per concrete class)
对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用<union-subclass>。
<class name="Payment">
<id name="id"type="long" column="PAYMENT_ID">
<generatorclass="sequence"/>
</id>
<propertyname="amount" column="AMOUNT"/>
...
<union-subclassname="CreditCardPayment" table="CREDIT_PAYMENT">
<propertyname="creditCardType" column="CCTYPE"/>
...
</union-subclass>
<union-subclassname="CashPayment" table="CASH_PAYMENT">
...
</union-subclass>
<union-subclassname="ChequePayment" table="CHEQUE_PAYMENT">
...
</union-subclass>
</class>
这里涉及三张表。每张表为对应类的所有属性（包括从超类继承的属性）定义相应字段。
这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类表中定义的相同。(我们可能会在Hibernate的后续发布版本中放宽此限制。) 不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy), 实际上, 主键的种子(primary key seed)不得不为同一继承层次中的全部被联合子类所共用.
10.1.6. Table per concrete class, usingimplicit polymorphism
10.1.6. Table per concrete class, usingimplicit polymorphism
另一种可供选择的方法是采用隐式多态：
<class name="CreditCardPayment"table="CREDIT_PAYMENT">
<id name="id"type="long" column="CREDIT_PAYMENT_ID">
<generatorclass="native"/>
</id>
<propertyname="amount" column="CREDIT_AMOUNT"/>
...
</class>
<class name="CashPayment" table="CASH_PAYMENT">
<id name="id"type="long" column="CASH_PAYMENT_ID">
<generatorclass="native"/>
</id>
<propertyname="amount" column="CASH_AMOUNT"/>
...
</class>
<class name="ChequePayment"table="CHEQUE_PAYMENT">
<id name="id"type="long" column="CHEQUE_PAYMENT_ID">
<generatorclass="native"/>
</id>
<propertyname="amount" column="CHEQUE_AMOUNT"/>
...
</class>
注意，我们没有在任何地方明确的提及接口Payment。同时注意 Payment的属性在每个子类中都进行了映射。如果你想避免重复，可以考虑使用XML实体(例如：位于DOCTYPE声明内的 [ <!ENTITY allproperties SYSTEM"allproperties.xml"> ]和映射中的&allproperties;)。
这种方法的缺陷在于，在Hibernate执行多态查询时(polymorphic queries)无法生成带UNION的SQL语句。
对于这种映射策略而言，通常用<any>来实现到 Payment的多态关联映射。
<any name="payment" meta-type="string"id-type="long">
<meta-valuevalue="CREDIT"/>
<meta-valuevalue="CASH"/>
<meta-valuevalue="CHEQUE"/>
<columnname="PAYMENT_CLASS"/>
<columnname="PAYMENT_ID"/>
</any>
10.1.7. 隐式多态和其他继承映射混合使用
对这一映射还有一点需要注意。因为每个子类都在各自独立的元素<class>中映射(并且Payment只是一个接口)，每个子类可以很容易的成为另一 个继承体系中的一部分！(你仍然可以对接口Payment使用多态查询。)
<class name="CreditCardPayment"table="CREDIT_PAYMENT">
<id name="id"type="long" column="CREDIT_PAYMENT_ID">
<generatorclass="native"/>
</id>
<discriminator column="CREDIT_CARD"type="string"/>
<propertyname="amount" column="CREDIT_AMOUNT"/>
...
<subclassname="MasterCardPayment" discriminator-value="MDC"/>
<subclassname="VisaPayment" discriminator-value="VISA"/>
</class>
<class name="NonelectronicTransaction"table="NONELECTRONIC_TXN">
<id name="id"type="long" column="TXN_ID">
<generatorclass="native"/>
</id>
...
<joined-subclassname="CashPayment" table="CASH_PAYMENT">
<keycolumn="PAYMENT_ID"/>
<propertyname="amount" column="CASH_AMOUNT"/>
...
</joined-subclass>
<joined-subclassname="ChequePayment" table="CHEQUE_PAYMENT">
<keycolumn="PAYMENT_ID"/>
<propertyname="amount" column="CHEQUE_AMOUNT"/>
...
</joined-subclass>
</class>
我们还是没有明确的提到Payment。 如果我们针对接口Payment执行查询 ――如from Payment―― Hibernate 自动返回CreditCardPayment(和它的子类，因为 它们也实现了接口Payment)、 CashPayment和Chequepayment的实例， 但不返回NonelectronicTransaction的实例。
10.2. 限制
对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态的 方式有一定的限制。而<union-subclass>映射的限制则没有那么严格。
下面表格中列出了在Hibernte中“每个具体类一张表”的策略和隐式多态的限制。
表10.1. 继承映射特性(Features of inheritance mappings)
继承策略(Inheritance strategy) |
多态多对一 |
多态一对一 |
多态一对多 |
多态多对多 |
多态 load()/get() |
多态查询 |
多态连接(join) |
外连接(Outer join)抓取 |
每个类分层结构一张表 |
<many-to-one> |
<one-to-one> |
<one-to-many> |
<many-to-many> |
s.get(Payment.class, id) |
from Payment p |
from Order o join o.payment p |
支持 |
每个子类一张表 |
<many-to-one> |
<one-to-one> |
<one-to-many> |
<many-to-many> |
s.get(Payment.class, id) |
from Payment p |
from Order o join o.payment p |
支持 |
每个具体类一张表(union-subclass) |
<many-to-one> |
<one-to-one> |
<one-to-many> (仅对于inverse="true"的情况) |
<many-to-many> |
s.get(Payment.class, id) |
from Payment p |
from Order o join o.payment p |
支持 |
每个具体类一张表(隐式多态) |
<any> |
不支持 |
不支持 |
<many-to-any> |
s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult() |
from Payment p |
不支持 |
不支持 |
第9 章组件（Component）映射 |
起始页 |
第11 章与对象共事 |
http://docs.huihoo.com/hibernate/reference-v3_zh-cn/inheritance.html