解读Hibernate继承映射策略

 Hibernate继承映射的英文是Inheritance Mappings，Hibernate继承映射有三种策略，下文对Hibernate继承映射策略具体理解。
Hibernate支持三种基本的继承映射策略：

◆每个类分层结构一张表(table per class hierarchy)

◆每个子类一张表(table per subclass)

◆每个具体类一张表(table per concrete class)

此外，Hibernate还支持第四种稍有不同的多态映射策略：

隐式多态(implicit polymorphism)

对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多 态来完成跨越整个层次的多态。但是在同一个<class>根元素 下，Hibernate不支持混合了元素<subclass>、 <joined-subclass>和<union-subclass> 的映射。在同一个<class>元素下，可以混合使用 “每个类分层结构一张表”（table per hierarchy） 和“每个子类一张表”（table per subclass） 这两种映射策略，这是通过结合元素<subclass>和 <join>来实现的（见后）。

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"> 
        <generator class="native"/> 
    </id> 
    <discriminator column="PAYMENT_TYPE" type="string"/> 
    <property name="amount" column="AMOUNT"/> 
    ...  
    <subclass name="CreditCardPayment" discriminator-value="CREDIT"> 
        <property name="creditCardType" column="CCTYPE"/> 
        ...  
    </subclass> 
    <subclass name="CashPayment" discriminator-value="CASH"> 
        ...  
    </subclass> 
    <subclass name="ChequePayment" discriminator-value="CHEQUE"> 
        ...  
    </subclass> 
</class> 

 

采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段， 如CCTYPE，不能有非空(NOT NULL)约束。

2. 每个类一张表(Table per subclass)

对于上例中的几个类而言，采用“每个类一张表”的映射策略，代码如下所示：

<class name="Payment" table="PAYMENT">
	<id name="id" type="long" column="PAYMENT_ID">
		<generator class="native" />
	</id>
	<property name="amount" column="AMOUNT" />
	...
	<joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">
		<key column="PAYMENT_ID" />
		...
	</joined-subclass>
	<joined-subclass name="CashPayment" table="CASH_PAYMENT">
		<key column="PAYMENT_ID" />
		<property name="creditCardType" column="CCTYPE" />
		...
	</joined-subclass>
	<joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
		<key column="PAYMENT_ID" />
		...
	</joined-subclass>
</class>

 

需要四张表。三个子类表通过主键关联到超类表(因而关系模型实际上是一对一关联)。

3. 每个子类一张表(Table per subclass)，使用辨别标志(Discriminator)

注意，对“每个子类一张表”的映射策略，Hibernate的实现不需要辨别字段，而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类 表中有一个类型辨别字段(type discriminator column)。Hibernate采用的方法更 难实现，但从关系（数据库）这点上来看，按理说它更正确。若你愿意使用带有辨别字 段的“每个子类一张表”的策略，你可以结合使用<subclass> 与<join>，如下所示：

<class name="Payment" table="PAYMENT"> 
    <id name="id" type="long" column="PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <discriminator column="PAYMENT_TYPE" type="string"/> 
    <property name="amount" column="AMOUNT"/>
    ...  
    <subclass name="CreditCardPayment" discriminator-value="CREDIT"> 
        <join table="CREDIT_PAYMENT"> 
            <property name="creditCardType" column="CCTYPE"/> 
            ...  
        </join> 
    </subclass> 
    <subclass name="CashPayment" discriminator-value="CASH"> 
        <join table="CASH_PAYMENT"> 
            ...  
        </join> 
    </subclass> 
    <subclass name="ChequePayment" discriminator-value="CHEQUE"> 
        <join table="CHEQUE_PAYMENT" fetch="select"> 
            ...  
        </join> 
    </subclass> 
</class> 

 

可选的声明fetch="select"，是用来告诉Hibernate，在查询超类时， 不要使用外部连接(outer join)来抓取子类ChequePayment的数据。

4. 混合使用“每个类分层结构一张表”和“每个子类一张表”

你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略：

<class name="Payment" table="PAYMENT"> 
    <id name="id" type="long" column="PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <discriminator column="PAYMENT_TYPE" type="string"/> 
    <property name="amount" column="AMOUNT"/> 
    ...  
    <subclass name="CreditCardPayment" discriminator-value="CREDIT"> 
        <join table="CREDIT_PAYMENT"> 
            <property name="creditCardType" column="CCTYPE"/> 
            ...  
        </join> 
    </subclass> 
    <subclass name="CashPayment" discriminator-value="CASH"> 
        ...  
    </subclass> 
    <subclass name="ChequePayment" discriminator-value="CHEQUE"> 
        ...  
    </subclass> 
</class> 

 

对上述任何一种映射策略而言，指向根类Payment的 关联是使用<many-to-one>进行映射的。

<many-to-one name="payment" column="PAYMENT_ID" class="Payment"/>

5. 每个具体类一张表(Table per concrete class)

对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用 <union-subclass>。

<class name="Payment">
    <id name="id" type="long" column="PAYMENT_ID"> 
        <generator class="sequence"/> 
    </id> 
    <property name="amount" column="AMOUNT"/>
    ... 
    <union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT"> 
        <property name="creditCardType" column="CCTYPE"/> 
        ...  
    </union-subclass> 
    <union-subclass name="CashPayment" table="CASH_PAYMENT"> 
        ...  
    </union-subclass> 
    <union-subclass name="ChequePayment" table="CHEQUE_PAYMENT"> 
        ...  
    </union-subclass> 
</class> 

 

这里涉及三张表。每张表为对应类的所有属性（包括从超类继承的属性）定义相应字段。

这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类 表中定义的相同。(我们可能会在Hibernate的后续发布版本中放宽此限制。) 不允许在联合子类(union subclass)的继承层次中使用标识生成器策略(identity generator strategy), 实际上, 主键的种子(primary key seed)不得不为同一继承层次中的全部被联合子类所共用.

6. Table per concrete class, using implicit polymorphism
另一种可供选择的方法是采用隐式多态：

<class name="CreditCardPayment" table="CREDIT_PAYMENT"> 
    <id name="id" type="long" column="CREDIT_PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <property name="amount" column="CREDIT_AMOUNT"/> 
    ...  
</class> 
<class name="CashPayment" table="CASH_PAYMENT"> 
    <id name="id" type="long" column="CASH_PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <property name="amount" column="CASH_AMOUNT"/> 
    ...  
</class>
<class name="ChequePayment" table="CHEQUE_PAYMENT"> 
    <id name="id" type="long" column="CHEQUE_PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <property name="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-value value="CREDIT" class="CreditCardPayment"/> 
    <meta-value value="CASH" class="CashPayment"/> 
    <meta-value value="CHEQUE" class="ChequePayment"/> 
    <column name="PAYMENT_CLASS"/> 
    <column name="PAYMENT_ID"/> 
</any> 

  

7. 隐式多态和其他继承映射混合使用

对这一映射还有一点需要注意。因为每个子类都在各自独立的元素<class> 中映射(并且Payment只是一个接口)，每个子类可以很容易的成为另一 个继承体系中的一部分！(你仍然可以对接口Payment使用多态查询。)

<class name="CreditCardPayment" table="CREDIT_PAYMENT"> 

    <id name="id" type="long" column="CREDIT_PAYMENT_ID"> 
        <generator class="native"/> 
    </id> 
    <discriminator column="CREDIT_CARD" type="string"/> 
    <property name="amount" column="CREDIT_AMOUNT"/> 
    ...  
    <subclass name="MasterCardPayment" discriminator-value="MDC"/> 
    <subclass name="VisaPayment" discriminator-value="VISA"/> 
</class> 

<class name="NonelectronicTransaction" table="NONELECTRONIC_TXN"> 
    <id name="id" type="long" column="TXN_ID"> 
        <generator class="native"/> 
    </id> 
    ...  
    <joined-subclass name="CashPayment" table="CASH_PAYMENT"> 
        <key column="PAYMENT_ID"/> 
        <property name="amount" column="CASH_AMOUNT"/> 
        ...  
    </joined-subclass>
    <joined-subclass name="ChequePayment" />

 改成 polymorphism="explicit"，则对其超类查询时，将无法查到该子类。