Hibernate

第9章组件（Component）映射

Component这个概念在Hibernate中几处不同的地方为了不同的目的被重复使用.

9.1.依赖对象（Dependent objects）

Component是一个被包含的对象,它作为值类型被持久化，而非一个被引用的实体。“component(组件)”这一术语指的是面向对象的合成概念（而并不是系统构架层次上的组件的概念）举个例子, 你可以对人（Person)如以下这样来建模：

public class Person {

private java.util.Date birthday;

private Name name;

private String key;

public String getKey() {

return key;

}

private void setKey(String key){

this.key=key;

}

public java.util.DategetBirthday() {

return birthday;

}

public voidsetBirthday(java.util.Date birthday) {

this.birthday = birthday;

}

public Name getName() {

return name;

}

public void setName(Name name) {

this.name = name;

}

......

......

}

public class Name {

char initial;

String first;

String last;

public String getFirst() {

return first;

}

void setFirst(String first) {

this.first = first;

}

public String getLast() {

return last;

}

void setLast(String last) {

this.last = last;

}

public char getInitial() {

return initial;

}

void setInitial(char initial) {

this.initial = initial;

}

}

现在,姓名(Name)是作为人(Person)的一个组成部分。需要注意的是:需要对姓名 的持久化属性定义getter和setter方法,但是不需要实现任何的接口或申明标识符字段。

以下是这个例子的Hibernate映射文件:

<class name="eg.Person" table="person">

<id name="Key"column="pid" type="string">

<generatorclass="uuid.hex"/>

</id>

<propertyname="birthday" type="date"/>

<componentname="Name" class="eg.Name"> <!-- class attributeoptional -->

<propertyname="initial"/>

<propertyname="first"/>

<propertyname="last"/>

</component>

</class>

人员(Person)表中将包括pid, birthday, initial, first和 last等字段。

就像所有的值类型一样, Component不支持共享引用。 换句话说，两个人可能重名，但是两个person对象应该包含两个独立的name对象，只不过是具有“同样”的值。 Component的值为空从语义学上来讲是专有的(ad hoc)。 每当 重新加载一个包含组件的对象,如果component的所有字段为空，那么将Hibernate将假定整个component为 空。对于绝大多数目的,这样假定是没有问题的。

Component的属性可以是Hibernate类型（包括Collections, many-to-one 关联，以及其它Component 等等）。嵌套Component不应该作为特殊的应用被考虑(Nested components should not be considered an exotic usage)。 Hibernate趋向于支持设计细致(fine-grained)的对象模型。

<component> 元素还允许有 <parent>子元素 ，用来表明component类中的一个属性返回包含它的实体的引用。

<class name="eg.Person" table="person">

<id name="Key"column="pid" type="string">

<generatorclass="uuid.hex"/>

</id>

<propertyname="birthday" type="date"/>

<componentname="Name" class="eg.Name" unique="true">>

<parentname="namedPerson"/> <!-- reference back to the Person -->

<propertyname="initial"/>

<propertyname="first"/>

<propertyname="last"/>

</component>

</class>

9.2.在集合中出现的依赖对象

Hibernate支持component的集合(例如: 一个元素是“姓名”这种类型的数组)。 你可以使用<composite-element>标签替代<element>标签来定义你的component集合。

<set name="someNames" table="some_names"lazy="true">

<keycolumn="id"/>

<composite-elementclass="eg.Name"> <!-- class attribute required -->

<propertyname="initial"/>

<propertyname="first"/>

<propertyname="last"/>

</composite-element>

</set>

注意，如果你决定定义一个元素是联合元素的Set，正确地实现equals()和hashCode()是非常重要的。

组合元素可以包含component但是不能包含集合。如果你的组合元素自身包含component, 必须使用<nested-composite-element>标签。这是一个相当特殊的案例 - 组合元素的集合自身可以包含component。 这个时候你就应该考虑一下使用one-to-many关联是否会更恰当。尝试对这个组合元素重新建模为一个实体－但是需要注意的是，虽然Java模型和重新建模前 是一样的，关系模型和持久性语义上仍然存在轻微的区别。

请注意如果你使用<set>标签,一个组合元素的映射不支持可能为空的属性. 当删除对象时, Hibernate必须使用每一个字段的来确定一条记录(在组合元素表中，没有单个的关键字段), 如果有为null的字段，这样做就不可能了。你必须作出一个选择，要么在组合元素中使用不能为空的属性，要么选择使用<list>, <map>,<bag> 或者 <idbag>而不是 <set>。

组合元素有个特别的案例，是组合元素可以包含一个<many-to-one> 元素。类似这样的映射允许你映射一个many-to-mang关联表作为组合元素额外的字段。(A mapping likethis allows you to map extra columns of a many-to-many association table to thecomposite element class.) 接下来的的例子是从Order到Item的一个多对多的关联关系,而 purchaseDate, price 和 quantity 是Item的关联属性。

<class name="eg.Order" .... >

....

<set name="purchasedItems"table="purchase_items" lazy="true">

<keycolumn="order_id">

<composite-elementclass="eg.Purchase">

<propertyname="purchaseDate"/>

<propertyname="price"/>

<propertyname="quantity"/>

<many-to-onename="item" class="eg.Item"/> <!-- class attribute isoptional -->

</composite-element>

</set>

</class>

当然，在另一方面，无法存在指向purchase的关联，因此不能实现双向关联查询。记住组建是值类型，并且不允许共享关联。单个Purchase 可以放在包含Order的集合中，但它不能同时被Item所关联。

即使三重或多重管理都是可能的:

<class name="eg.Order" .... >

....

<setname="purchasedItems" table="purchase_items"lazy="true">

<keycolumn="order_id">

<composite-elementclass="eg.OrderLine">

<many-to-onename="purchaseDetails" class="eg.Purchase"/>

<many-to-onename="item" class="eg.Item"/>

</composite-element>

</set>

</class>

在查询中，组合元素使用的语法是和关联到其他实体的语法一样的。

9.3.组件作为Map的索引（Componentsas Map indices ）

<composite-map-key>元素允许你映射一个Component类作为Map的key， 但是你必须确定你正确的在这个类中重写了hashCode() 和 equals()方法。

9.4.组件作为联合标识符(Components as compositeidentifiers)

你可以使用一个component作为一个实体类的标识符。 你的component类必须满足以下要求：

·它必须实现java.io.Serializable接口

·它必须重新实现equals()和hashCode()方法, 始终和组合关键字在数据库中的概念保持一致

注意：在Hibernate3中，第二种要求并非是Hibernate强制必须的。但最好这样做。

你不能使用一个IdentifierGenerator产生组合关键字。作为替代应用程序必须分配它自己的标识符。

使用<composite-id> 标签(并且内嵌<key-property>元素)代替通常的<id>标签。 比如,OrderLine类具有一个依赖Order的(联合)主键的主键。

<class name="OrderLine">

<composite-idname="id" class="OrderLineId">

<key-propertyname="lineId"/>

<key-propertyname="orderId"/>

<key-propertyname="customerId"/>

</composite-id>

<propertyname="name"/>

<many-to-onename="order" class="Order"

insert="false"update="false">

<columnname="orderId"/>

<columnname="customerId"/>

</many-to-one>

....

</class>

现在，任何关联到OrderLine 的外键都是复合的。在你的映射文件中，必须为其他类也这样声明。指向OrderLine的关联可能被这样映射：

<many-to-one name="orderLine" class="OrderLine">

<!-- the "class" attribute is optional, as usual -->

<columnname="lineId"/>

<columnname="orderId"/>

<columnname="customerId"/>

</many-to-one>

（注意在各个地方<column>标签都是column属性的替代写法。）

指向OrderLine的多对多关联也使用联合外键:

<set name="undeliveredOrderLines">

<key columnname="warehouseId"/>

<many-to-manyclass="OrderLine">

<columnname="lineId"/>

<columnname="orderId"/>

<column name="customerId"/>

</many-to-many>

</set>

在Order中,OrderLine的集合则是这样:

<set name="orderLines" inverse="true">

<key>

<columnname="orderId"/>

<columnname="customerId"/>

</key>

<one-to-manyclass="OrderLine"/>

</set>

(与通常一样,<one-to-many>元素不声明任何列.)

假若OrderLine本身拥有一个集合,它也具有组合外键。

<class name="OrderLine">

....

....

<listname="deliveryAttempts">

<key> <!-- a collection inherits the compositekey type -->

<columnname="lineId"/>

<columnname="orderId"/>

<columnname="customerId"/>

</key>

<list-indexcolumn="attemptId" base="1"/>

<composite-elementclass="DeliveryAttempt">

...

</composite-element>

</set>

</class>

9.5.动态组件 （Dynamic components）

你甚至可以映射Map类型的属性：

<dynamic-component name="userAttributes">

<propertyname="foo" column="FOO"/>

<propertyname="bar" column="BAR"/>

<many-to-onename="baz" class="Baz" column="BAZ_ID"/>

</dynamic-component>

从<dynamic-component>映射的语义上来讲，它和<component>是相同的。 这种映射类型的优点在于通过修改映射文件，就可以具有在部署时检测真实属性的能力.利用一个DOM解析器，是有可能在运行时刻操作映射文件的。 更好的是，你可以通过Configuration对象来访问（或者修改）Hibernate的运行时元模型。

---

第8章关联关系映射	起始页	第10章继承映射(Inheritance Mappings)

http://docs.huihoo.com/hibernate/reference-v3_zh-cn/components.html