2005-05-21 14:59:07 -04:00
<chapter id= "collections" >
<title > 集合类(Collections)映射</title>
<sect1 id= "collections-persistent" revision= "3" >
<title > 持久化集合类(Persistent collections)</title>
<para id= "collections-persistent-translate-comment" >
(译者注：在阅读本章的时候，以后整个手册的阅读过程中，我们都会面临一个名词方面的问题，那就是“集合”。"Collections"和"Set"在中文里对应都被翻译为“集合”， ， ， ， ， ，
与此同时， ， ， ；
本章中,特别是后半部分是需要反复阅读才能理解清楚的。如果遇到任何疑问,请记住,英文版本的reference是惟一标准的参考资料。)
</para>
<para >
Hibernate要求持久化集合值字段必须声明为接口， ：
</para>
<programlisting > < ![CDATA[public class Product {
private String serialNumber;
private Set parts = new HashSet();
public Set getParts() { return parts; }
void setParts(Set parts) { this.parts = parts; }
public String getSerialNumber() { return serialNumber; }
void setSerialNumber(String sn) { serialNumber = sn; }
}]]></programlisting>
<para >
实际的接口可能是<literal > java.util.Set</literal> ,
<literal > java.util.Collection</literal> , <literal > java.util.List</literal> ,
<literal > java.util.Map</literal> , <literal > java.util.SortedSet</literal> ,
<literal > java.util.SortedMap</literal> 或者...任何你喜欢的类型！("任何你喜欢的类型" 代表你需要编写 <literal > org.hibernate.usertype.UserCollectionType</literal> 的实现.)
</para>
<para >
注意我们是如何用一个<literal > HashSet</literal> 实例来初始化实例变量的.这是用于初始化新创建(尚未持久化)的类实例中集合值属性的最佳方法。当你持久化这个实例时——比如通过调用<literal > persist()</literal> ——Hibernate 会自动把<literal > HashSet</literal> 替换为Hibernate自己的<literal > Set</literal> 实现。观察下面的错误：
</para>
<programlisting > < ![CDATA[Cat cat = new DomesticCat();
Cat kitten = new DomesticCat();
....
Set kittens = new HashSet();
kittens.add(kitten);
cat.setKittens(kittens);
session.persist(cat);
kittens = cat.getKittens(); //Okay, kittens collection is a Set
(HashSet) cat.getKittens(); //Error!]]></programlisting>
<para >
根据不同的接口类型， <literal > HashMap</literal> , <literal > HashSet</literal> ,
<literal > TreeMap</literal> , <literal > TreeSet</literal> or
<literal > ArrayList</literal> 。
</para>
<para >
集合类实例具有值类型的通常行为。当被持久化对象引用后， ， ， ， ， ；
</para>
<para >
你不需要过多的为此担心。就如同你平时使用普通的Java集合类一样来使用持久化集合类。只是要确认你理解了双向关联的语义（ ）
</para>
</sect1>
<sect1 id= "collections-mapping" revision= "2" >
<title > 集合映射（ Collection mappings ） </title>
<para >
用于映射集合类的Hibernate映射元素取决于接口的类型。比如， <literal > < set> </literal> 元素用来映射<literal > Set</literal> 类型的属性。
</para>
<programlisting > <![CDATA[<class name="Product">
<id name= "serialNumber" column= "productSerialNumber" />
<set name= "parts" >
<key column= "productSerialNumber" not-null= "true" />
<one-to-many class= "Part" />
</set>
</class> ]]></programlisting>
<para >
除了<literal > < set> </literal> ,还有<literal > < list> </literal> , <literal > < map> </literal> , <literal > < bag> </literal> , <literal > < array> </literal> 和
<literal > < primitive-array> </literal> 映射元素。<literal > < map> </literal> 具有代表性：
</para>
<programlistingco >
<areaspec >
<area id= "mappingcollection1" coords= "2 65" />
<area id= "mappingcollection2" coords= "3 65" />
<area id= "mappingcollection3" coords= "4 65" />
<area id= "mappingcollection4" coords= "5 65" />
<area id= "mappingcollection5" coords= "6 65" />
<area id= "mappingcollection6" coords= "7 65" />
<area id= "mappingcollection7" coords= "8 65" />
<area id= "mappingcollection8" coords= "9 65" />
<area id= "mappingcollection9" coords= "10 65" />
<area id= "mappingcollection10" coords= "11 65" />
<area id= "mappingcollection11" coords= "12 65" />
<area id= "mappingcollection12" coords= "13 65" />
<area id= "mappingcollection13" coords= "14 65" />
</areaspec>
<programlisting > < ![CDATA[<map
name="propertyName"
table="table_name"
schema="schema_name"
lazy="true|false"
inverse="true|false"
cascade="all|none|save-update|delete|all-delete-orphan"
sort="unsorted|natural|comparatorClass"
order-by="column_name asc|desc"
where="arbitrary sql where condition"
fetch="join|select|subselect"
batch-size="N"
access="field|property|ClassName"
optimistic-lock="true|false"
node="element-name|."
embed-xml="true|false"
>
<key . . . . />
<map-key . . . . />
<element . . . . />
</map> ]]></programlisting>
<calloutlist >
<callout arearefs= "mappingcollection1" >
<para >
<literal > name</literal> 集合属性的名称
</para>
</callout>
<callout arearefs= "mappingcollection2" >
<para >
<literal > table</literal> （可选——默认为属性的名称）这个集合表的名称(不能在一对多的关联关系中使用)
</para>
</callout>
<callout arearefs= "mappingcollection3" >
<para >
<literal > schema</literal> (可选) 表的schema的名称, 他将覆盖在根元素中定义的schema
</para>
</callout>
<callout arearefs= "mappingcollection4" >
<para >
<literal > lazy</literal> (可选--默认为true) 可以用来关闭延迟加载，指定一直使用预先抓取（对数组不适用）
</para>
</callout>
<callout arearefs= "mappingcollection5" >
<para >
<literal > inverse</literal> (可选——默认为<literal > false</literal> )
标记这个集合作为双向关联关系中的方向一端。
</para>
</callout>
<callout arearefs= "mappingcollection6" >
<para >
<literal > cascade</literal> (可选——默认为<literal > none</literal> )
让操作级联到子实体
</para>
</callout>
<callout arearefs= "mappingcollection7" >
<para >
<literal > sort</literal> (可选)指定集合的排序顺序, 其可以为自然的(<literal > natural</literal> )或者给定一个用来比较的类。
</para>
</callout>
<callout arearefs= "mappingcollection8" >
<para >
<literal > order-by</literal> (可选, 仅用于jdk1.4) 指定表的字段(一个或几个)再加上asc或者desc(可选), 定义Map,Set和Bag的迭代顺序
</para>
</callout>
<callout arearefs= "mappingcollection9" >
<para >
<literal > where</literal> (可选) 指定任意的SQL where条件, 该条件将在重新载入或者删除这个集合时使用(当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常有用)
</para>
</callout>
<callout arearefs= "mappingcollection10" >
<para >
<literal > fetch</literal> (可选, 默认为<literal > select</literal> ) 用于在外连接抓取、通过后续select抓取和通过后续subselect抓取之间选择。
</para>
</callout>
<callout arearefs= "mappingcollection11" >
<para >
<literal > batch-size</literal> (可选, 默认为<literal > 1</literal> ) 指定通过延迟加载取得集合实例的批处理块大小（"batch size"）。
</para>
</callout>
<callout arearefs= "mappingcollection12" >
<para >
<literal > access</literal> (可选-默认为属性property):Hibernate取得属性值时使用的策略
</para>
</callout>
<callout arearefs= "mappingcollection12" >
<para >
<literal > 乐观锁</literal> (可选 - 默认为 <literal > true</literal> ):
对集合的状态的改变会是否导致其所属的实体的版本增长。 (对一对多关联来说，关闭这个属性常常是有理的)
</para>
</callout>
</calloutlist>
</programlistingco>
<sect2 id= "collections-foreignkeys" >
<title > 集合外键(Collection foreign keys)</title>
<para >
集合实例在数据库中依靠持有集合的实体的外键加以辨别。此外键作为<emphasis > 集合关键字段（ ） </emphasis> （或多个字段）加以引用。集合关键字段通过<literal > < key> </literal> 元素映射。
</para>
<para >
在外键字段上可能具有非空约束。对于大多数集合来说，这是隐含的。对单向一对多关联来说，外键字段默认是可以为空的，因此你可能需要指明 <literal > not-null="true"</literal> 。
</para>
<programlisting > <![CDATA[<key column="productSerialNumber" not-null="true"/>]]> </programlisting>
<para >
外键约束可以使用<literal > ON DELETE CASCADE</literal> 。
</para>
<programlisting > <![CDATA[<key column="productSerialNumber" on-delete="cascade"/>]]> </programlisting>
<para >
对<literal > < key> </literal> 元素的完整定义，请参阅前面的章节。
</para>
</sect2>
<sect2 id= "collections-elements" >
<title > 集合元素（ ） </title>
<para >
集合几乎可以包含任何其他的Hibernate类型， ， ： （ ） ， ， ， ，
</para>
<para >
被包容的类型被称为<emphasis > 集合元素类型（ ） </emphasis> 。集合元素通过<literal > < element> </literal> 或<literal > < composite-element> </literal> 映射，或在其是实体引用的时候，通过<literal > < one-to-many> </literal> 或<literal > < many-to-many> </literal> 映射。前两种用于使用值语义映射元素，后两种用于映射实体关联。
</para>
</sect2>
<sect2 id= "collections-indexed" >
<title > 索引集合类(Indexed collections)</title>
<para >
所有的集合映射， ， <emphasis > 索引字段(index column)</emphasis> ——用于对应到数组索引，或者<literal > List</literal> 的索引，或者<literal > Map</literal> 的关键字。通过<literal > < map-key> </literal> ,<literal > Map</literal> 的索引可以是任何基础类型；若通过<literal > < map-key-many-to-many> </literal> ，它也可以是一个实体引用；若通过<literal > < composite-map-key> </literal> ，它还可以是一个组合类型。数组或列表的索引必须是<literal > integer</literal> 类型，并且使用 <literal > < list-index> </literal> 元素定义映射。被映射的字段包含有顺序排列的整数（ ）
</para>
<programlistingco >
<areaspec >
<area id= "mapkey1" coords= "2 45" />
<area id= "mapkey2" coords= "3 45" />
<area id= "mapkey3" coords= "4 45" />
</areaspec>
<programlisting > < ![CDATA[<map-key
column="column_name"
formula="any SQL expression"
type="type_name"
node="@attribute-name"
length="N"/>]]></programlisting>
<calloutlist >
<callout arearefs= "mapkey1" >
<para >
<literal > column</literal> (可选):保存集合索引值的字段名。
</para>
</callout>
<callout arearefs= "mapkey2" >
<para >
<literal > formula</literal> (可选): 用于计算map关键字的SQL公式
</para>
</callout>
<callout arearefs= "mapkey3" >
<para >
<literal > type</literal> (可选,默认为整型<literal > integer</literal> ):集合索引的类型。
</para>
</callout>
</calloutlist>
</programlistingco>
<programlistingco >
<areaspec >
<area id= "indexmanytomany1" coords= "2 45" />
<area id= "indexmanytomany2" coords= "3 45" />
<area id= "indexmanytomany3" coords= "3 45" />
</areaspec>
<programlisting > < ![CDATA[<map-key-many-to-many
column="column_name"
formula="any SQL expression"
class="ClassName"
/>]]></programlisting>
<calloutlist >
<callout arearefs= "indexmanytomany1" >
<para >
<literal > column</literal> (可选):集合索引值中外键字段的名称
</para>
</callout>
<callout arearefs= "indexmanytomany2" >
<para >
<literal > formula</literal> (可选): 用于计算map关键字的外键的SQL公式
</para>
</callout>
<callout arearefs= "indexmanytomany3" >
<para >
<literal > class</literal> (必需):集合的索引使用的实体类。
</para>
</callout>
</calloutlist>
</programlistingco>
<para >
假若你的表没有一个索引字段,当你仍然希望使用<literal > List</literal> 作为属性类型,你应该把此属性映射为Hibernate <emphasis > < bag> </emphasis> 。从数据库中获取的时候， ，
</para>
</sect2>
<para >
从集合类可以产生很大一部分映射， ，
</para>
<sect2 id= "collections-ofvalues" revision= "1" >
<title > 值集合于多对多关联(Collections of values and many-to-many associations)</title>
<para >
任何值集合或者多对多关联需要专用的具有一个或多个外键字段的<emphasis > collection table</emphasis> 、一个或多个<emphasis > collection element column</emphasis> ，以及还可能有一个或多个索引字段。
</para>
<para >
对于一个值集合, 我们使用<literal > < element> </literal> 标签。
</para>
<programlistingco >
<areaspec >
<area id= "element1b" coords= "2 50" />
<area id= "element2b" coords= "3 50" />
<area id= "element3b" coords= "4 50" />
</areaspec>
<programlisting > < ![CDATA[<element
column="column_name"
formula="any SQL expression"
type="typename"
length="N"
precision="N"
scale="N"
not-null="true|false"
unique="true|false"
node="element-name"
/>]]></programlisting>
<calloutlist >
<callout arearefs= "element1b" >
<para >
<literal > column</literal> (可选):保存集合元素值的字段名。
</para>
</callout>
<callout arearefs= "element2b" >
<para >
<literal > formula</literal> (可选): 用于计算元素的SQL公式
</para>
</callout>
<callout arearefs= "element3b" >
<para >
<literal > type</literal> (必需):集合元素的类型
</para>
</callout>
</calloutlist>
</programlistingco>
<para >
<emphasis > 多对多关联(many-to-many association)</emphasis> 使用
<literal > < many-to-many> </literal> 元素定义.
</para>
<programlistingco >
<areaspec >
<area id= "manytomany1" coords= "2 60" />
<area id= "manytomany2" coords= "3 60" />
<area id= "manytomany3" coords= "4 60" />
<area id= "manytomany4" coords= "5 60" />
<area id= "manytomany5" coords= "6 60" />
<area id= "manytomany6" coords= "7 60" />
<area id= "manytomany7" coords= "8 60" />
</areaspec>
<programlisting > < ![CDATA[<many-to-many
column="column_name"
formula="any SQL expression"
class="ClassName"
fetch="select|join"
unique="true|false"
not-found="ignore|exception"
entity-name="EntityName"
node="element-name"
embed-xml="true|false"
/>]]></programlisting>
<calloutlist >
<callout arearefs= "manytomany1" >
<para >
<literal > column</literal> (可选): 这个元素的外键关键字段名
</para>
</callout>
<callout arearefs= "manytomany2" >
<para >
<literal > formula</literal> (可选): 用于计算元素外键值的SQL公式.
</para>
</callout>
<callout arearefs= "manytomany3" >
<para >
<literal > class</literal> (必需): 关联类的名称
</para>
</callout>
<callout arearefs= "manytomany3" >
<para >
<literal > outer-join</literal> (可选 - 默认为<literal > auto</literal> ):
在Hibernate系统参数中<literal > hibernate.use_outer_join</literal> 被打开的情况下,该参数用来允许使用outer join来载入此集合的数据。
</para>
</callout>
<callout arearefs= "manytomany4" >
<para >
为此关联打开外连接抓取或者后续select抓取。这是特殊情况； （ <literal > SELECT</literal> )，你不仅需要对集合自身打开<literal > join</literal> ，也需要对<literal > < many-to-many> </literal> 这个内嵌元素打开此属性。
</para>
</callout>
<callout arearefs= "manytomany5" >
<para >
对外键字段允许DDL生成的时候生成一个惟一约束。这使关联变成了一个高效的一对多关联。（ ：
</para>
</callout>
<callout arearefs= "manytomany6" >
<para >
<literal > not-found</literal> (可选 - 默认为 <literal > exception</literal> ): 指明引用的外键中缺少某些行该如何处理：
<literal > ignore</literal> 会把缺失的行作为一个空引用处理。
</para>
</callout>
<callout arearefs= "manytomany7" >
<para >
<literal > entity-name</literal> (可选): 被关联的类的实体名，作为<literal > class</literal> 的替代。
</para>
</callout>
</calloutlist>
</programlistingco>
<para >
例子：首先, 一组字符串：
</para>
<programlisting > <![CDATA[<set name="names" table="NAMES">
<key column= "GROUPID" />
<element column= "NAME" type= "string" />
</set> ]]></programlisting>
<para >
包含一组整数的bag(还设置了<literal > order-by</literal> 参数指定了迭代的顺序)：
</para>
<programlisting > < ![CDATA[<bag name= "sizes"
table="item_sizes"
order-by="size asc">
<key column= "item_id" />
<element column= "size" type= "integer" />
</bag> ]]></programlisting>
<para >
一个实体数组,在这个案例中是一个多对多的关联(注意这里的实体是自动管理生命周期的对象（ ） <literal > cascade="all"</literal> ):
</para>
<programlisting > < ![CDATA[<array name= "addresses"
table="PersonAddress"
cascade="persist">
<key column= "personId" />
<list-index column= "sortOrder" />
<many-to-many column= "addressId" class= "Address" />
</array> ]]></programlisting>
<para >
一个map,通过字符串的索引来指明日期：
</para>
<programlisting > < ![CDATA[<map name= "holidays"
table="holidays"
schema="dbo"
order-by="hol_name asc">
<key column= "id" />
<map-key column= "hol_name" type= "string" />
<element column= "hol_date" type= "date" />
</map> ]]></programlisting>
<para >
一个组件的列表：（下一章讨论）
</para>
<programlisting > < ![CDATA[<list name= "carComponents"
table="CarComponents">
<key column= "carId" />
<list-index column= "sortOrder" />
<composite-element class= "CarComponent" >
<property name= "price" />
<property name= "type" />
<property name= "serialNumber" column= "serialNum" />
</composite-element>
</list> ]]></programlisting>
</sect2>
<sect2 id= "collections-onetomany" >
<title > 一对多关联（ ） </title>
<para >
<emphasis > 一对多关联</emphasis> <emphasis > 通过外键</emphasis> 连接两个类对应的表,而没有中间集合表。 这个关系模型失去了一些Java集合的语义:
</para>
<itemizedlist spacing= "compact" >
<listitem >
<para >
一个被包含的实体的实例只能被包含在一个集合的实例中
</para>
</listitem>
<listitem >
<para >
一个被包含的实体的实例只能对应于集合索引的一个值中
</para>
</listitem>
</itemizedlist>
<para >
一个从<literal > Product</literal> 到<literal > Part</literal> 的关联需要关键字字段,可能还有一个索引字段指向<literal > Part</literal> 所对应的表。 <literal > < one-to-many> </literal> 标记指明了一个一对多的关联。
</para>
<programlistingco >
<areaspec >
<area id= "onetomany1" coords= "2 60" />
<area id= "onetomany2" coords= "3 60" />
<area id= "onetomany3" coords= "4 60" />
</areaspec>
<programlisting > < ![CDATA[<one-to-many
class="ClassName"
not-found="ignore|exception"
entity-name="EntityName"
node="element-name"
embed-xml="true|false"
/>]]></programlisting>
<calloutlist >
<callout arearefs= "onetomany1" >
<para >
<literal > class</literal> (必须):被关联类的名称。
</para>
</callout>
<callout arearefs= "onetomany2" >
<para >
<literal > not-found</literal> (可选 - 默认为<literal > exception</literal> ):
指明若缓存的标示值关联的行缺失,该如何处理:
<literal > ignore</literal> 会把缺失的行作为一个空关联处理。
</para>
</callout>
<callout arearefs= "onetomany3" >
<para >
<literal > entity-name</literal> (可选): 被关联的类的实体名，作为<literal > class</literal> 的替代。
</para>
</callout>
</calloutlist>
</programlistingco>
<para >
例子
</para>
<programlisting > <![CDATA[<set name="bars">
<key column= "foo_id" />
<one-to-many class= "org.hibernate.Bar" />
</set> ]]></programlisting>
<para >
注意:<literal > < one-to-many> </literal> 元素不需要定义任何字段。 也不需要指定表名。
</para>
<para >
<emphasis > 重要提示</emphasis> :如果<literal > 一对多</literal> 关联中的外键字段定义成<literal > NOT NULL</literal> ,你必须把<literal > < key> </literal> 映射声明为<literal > not-null="true"</literal> ,或者使用<emphasis > 双向关联</emphasis> ，并且标明<literal > inverse="true"</literal> 。参阅本章后面关于双向关联的讨论。
</para>
<para >
下面的例子展示一个<literal > Part</literal> 实体的map,把name作为关键字。( <literal > partName</literal> 是<literal > Part</literal> 的持久化属性)。注意其中的基于公式的索引的用法。
</para>
<programlisting > < ![CDATA[<map name= "parts"
cascade="all">
<key column= "productId" not-null= "true" />
<map-key formula= "partName" />
<one-to-many class= "Part" />
</map> ]]></programlisting>
</sect2>
</sect1>
<sect1 id= "collections-advancedmappings" >
<title > 高级集合映射（ ） </title>
<sect2 id= "collections-sorted" revision= "2" >
<title > 有序集合（ ） </title>
<para >
Hibernate支持实现<literal > java.util.SortedMap</literal> 和<literal > java.util.SortedSet</literal> 的集合。
你必须在映射文件中指定一个比较器：
</para>
<programlisting > < ![CDATA[<set name= "aliases"
table="person_aliases"
sort="natural">
<key column= "person" />
<element column= "name" type= "string" />
</set>
<map name= "holidays" sort= "my.custom.HolidayComparator" >
<key column= "year_id" />
<map-key column= "hol_name" type= "string" />
<element column= "hol_date" type= "date" />
</map> ]]></programlisting>
<para >
<literal > sort</literal> 属性中允许的值包括<literal > unsorted</literal> ,<literal > natural</literal> 和某个实现了<literal > java.util.Comparator</literal> 的类的名称。
</para>
<para >
分类集合的行为事实上象<literal > java.util.TreeSet</literal> 或者<literal > java.util.TreeMap</literal> 。
</para>
<para >
如果你希望数据库自己对集合元素排序，可以利用<literal > set</literal> ,<literal > bag</literal> 或者<literal > map</literal> 映射中的<literal > order-by</literal> 属性。这个解决方案只能在jdk1.4或者更高的jdk版本中才可以实现(通过LinkedHashSet或者
LinkedHashMap实现)。 它是在SQL查询中完成排序，
</para>
<programlisting > <![CDATA[<set name="aliases" table="person_aliases" order-by="lower(name) asc">
<key column= "person" />
<element column= "name" type= "string" />
</set>
<map name= "holidays" order-by= "hol_date, hol_name" >
<key column= "year_id" />
<map-key column= "hol_name" type= "string" />
<element column= "hol_date" type= "date" />
</map> ]]></programlisting>
<para >
注意: 这个<literal > order-by</literal> 属性的值是一个SQL排序子句而不是HQL的！
</para>
<para >
关联还可以在运行时使用集合<literal > filter()</literal> 根据任意的条件来排序。
</para>
<programlisting > <![CDATA[sortedUsers = s.createFilter( group.getUsers(), "order by this.name" ).list();]]> </programlisting>
</sect2>
<sect2 id= "collections-bidirectional" revision= "1" >
<title > 双向关联（ ） </title>
<para >
<emphasis > 双向关联</emphasis> 允许通过关联的任一端访问另外一端。在Hibernate中, 支持两种类型的双向关联:
<variablelist >
<varlistentry >
<term > 一对多（ ） </term>
<listitem >
<para >
Set或者bag值在一端, 单独值(非集合)在另外一端
</para>
</listitem>
</varlistentry>
<varlistentry >
<term > 多对多（ ） </term>
<listitem >
<para >
两端都是set或bag值
</para>
</listitem>
</varlistentry>
</variablelist>
</para>
<para >
要建立一个双向的多对多关联， ， <emphasis > inverse</emphasis> (使用哪一端要根据你的选择，但它不能是一个索引集合)。
</para>
<para >
这里有一个many-to-many的双向关联的例子;每一个category都可以有很多items,每一个items可以属于很多categories：
</para>
<programlisting > <![CDATA[<class name="Category">
<id name= "id" column= "CATEGORY_ID" />
...
<bag name= "items" table= "CATEGORY_ITEM" >
<key column= "CATEGORY_ID" />
<many-to-many class= "Item" column= "ITEM_ID" />
</bag>
</class>
<class name= "Item" >
<id name= "id" column= "CATEGORY_ID" />
...
<!-- inverse end -->
<bag name= "categories" table= "CATEGORY_ITEM" inverse= "true" >
<key column= "ITEM_ID" />
<many-to-many class= "Category" column= "CATEGORY_ID" />
</bag>
</class> ]]></programlisting>
<para >
如果只对关联的反向端进行了改变，这个改变<emphasis > 不会</emphasis> 被持久化。
这表示Hibernate为每个双向关联在内存中存在两次表现,一个从A连接到B,另一个从B连接到A。如果你回想一下Java对象模型， ， ：
</para>
<programlisting > < ![CDATA[
category.getItems().add(item); // The category now "knows" about the relationship
item.getCategories().add(category); // The item now "knows" about the relationship
session.persist(item); // The relationship won''t be saved!
session.persist(category); // The relationship will be saved]]></programlisting>
<para >
非反向端用于把内存中的表示保存到数据库中。
</para>
<para >
要建立一个一对多的双向关联，你可以通过把一个一对多关联，作为一个多对一关联映射到到同一张表的字段上，并且在"多"的那一端定义<literal > inverse="true"</literal> 。
</para>
<programlisting > <![CDATA[<class name="Parent">
<id name= "id" column= "parent_id" />
....
<set name= "children" inverse= "true" >
<key column= "parent_id" />
<one-to-many class= "Child" />
</set>
</class>
<class name= "eg.Child" >
<id name= "id" column= "id" />
....
<many-to-one name= "parent"
class="Parent"
column="parent_id"
not-null="true"/>
</class> ]]></programlisting>
<para >
在“一”这一端定义<literal > inverse="true"</literal> 不会影响级联操作，二者是正交的概念！
</para>
</sect2>
<sect2 id= "collections-ternary" >
<title > 三重关联（ ） </title>
<para >
有三种可能的途径来映射一个三重关联。第一种是使用一个<literal > Map</literal> ，把一个关联作为其索引：
</para>
<programlisting > <![CDATA[<map name="contracts">
<key column= "employer_id" not-null= "true" />
<map-key-many-to-many column= "employee_id" class= "Employee" />
<one-to-many class= "Contract" />
</map> ]]></programlisting>
<programlisting > <![CDATA[<map name="connections">
<key column= "incoming_node_id" />
<map-key-many-to-many column= "outgoing_node_id" class= "Node" />
<many-to-many column= "connection_id" class= "Connection" />
</map> ]]></programlisting>
<para >
第二种方法是简单的把关联重新建模为一个实体类。这使我们最经常使用的方法。
</para>
<para >
最后一种选择是使用复合元素，我们会在后面讨论
</para>
</sect2>
<sect2 id= "collections-idbag" revision= "1" >
<title > <literal > 使用< idbag> </literal> </title>
<para >
如果你完全信奉我们对于“联合主键（ ） ， （ ） （ ） ， ， ！ ， ； （ <emphasis > 可能</emphasis> 会获得一点好处） ， （ ） ，
</para>
<para >
<literal > < idbag> </literal> 属性让你使用bag语义来映射一个<literal > List</literal> (或<literal > Collection</literal> )。
</para>
<programlisting > <![CDATA[<idbag name="lovers" table="LOVERS">
<collection-id column= "ID" type= "long" >
<generator class= "sequence" />
</collection-id>
<key column= "PERSON1" />
2005-06-19 12:50:03 -04:00
<many-to-many column= "PERSON2" class= "Person" fetch= "join" />
2005-05-21 14:59:07 -04:00
</idbag> ]]></programlisting>
<para >
你可以理解，<literal > < idbag> </literal> 人工的id生成器， ！ ，
</para>
<para >
注意<literal > < idbag> </literal> 的更新性能要比普通的<literal > < bag> </literal> 高得多！ ， ，
</para>
<para >
在目前的实现中，还不支持使用<literal > identity</literal> 标识符生成器策略来生成<literal > < idbag> </literal> 集合的标识符。
</para>
</sect2>
</sect1>
<!-- undocumenting this stuff -->
<!-- sect1 id="collections - heterogeneous">
<title > 异类关联(Heterogeneous Associations)</title>
<para >
<literal > < many-to-any> </literal> 和<literal > < index-many-to-any> </literal> 元素提供真正的异类关联。这些元素和<literal > < any> </literal> 元素工作方式是同样的,他们都应该很少用到。
</para>
</sect1-->
<sect1 id= "collections-example" revision= "1" >
<title > 集合例子（ ） </title>
<para >
在前面的几个章节的确非常令人迷惑。 因此让我们来看一个例子。这个类：
</para>
<programlisting > < ![CDATA[package eg;
import java.util.Set;
public class Parent {
private long id;
private Set children;
public long getId() { return id; }
private void setId(long id) { this.id=id; }
private Set getChildren() { return children; }
private void setChildren(Set children) { this.children=children; }
....
....
}]]></programlisting>
<para >
这个类有一个<literal > Child</literal> 的实例集合。如果每一个子实例至多有一个父实例, 那么最自然的映射是一个one-to-many的关联关系：
</para>
<programlisting > <![CDATA[<hibernate-mapping>
<class name= "Parent" >
<id name= "id" >
<generator class= "sequence" />
</id>
<set name= "children" >
<key column= "parent_id" />
<one-to-many class= "Child" />
</set>
</class>
<class name= "Child" >
<id name= "id" >
<generator class= "sequence" />
</id>
<property name= "name" />
</class>
</hibernate-mapping> ]]></programlisting>
<para >
在以下的表定义中反应了这个映射关系：
</para>
<programlisting > < ![CDATA[create table parent ( id bigint not null primary key )
create table child ( id bigint not null primary key, name varchar(255), parent_id bigint )
alter table child add constraint childfk0 (parent_id) references parent]]></programlisting>
<para >
如果父亲是<emphasis > 必须</emphasis> 的, 那么就可以使用双向one-to-many的关联了：
</para>
<programlisting > <![CDATA[<hibernate-mapping>
<class name= "Parent" >
<id name= "id" >
<generator class= "sequence" />
</id>
<set name= "children" inverse= "true" >
<key column= "parent_id" />
<one-to-many class= "Child" />
</set>
</class>
<class name= "Child" >
<id name= "id" >
<generator class= "sequence" />
</id>
<property name= "name" />
<many-to-one name= "parent" class= "Parent" column= "parent_id" not-null= "true" />
</class>
</hibernate-mapping> ]]></programlisting>
<para >
请注意<literal > NOT NULL</literal> 的约束:
</para>
<programlisting > < ![CDATA[create table parent ( id bigint not null primary key )
create table child ( id bigint not null
primary key,
name varchar(255),
parent_id bigint not null )
alter table child add constraint childfk0 (parent_id) references parent]]></programlisting>
<para >
另外，如果你绝对坚持这个关联应该是单向的，你可以对<literal > < key> </literal> 映射声明<literal > NOT NULL</literal> 约束：
</para>
<programlisting > <![CDATA[<hibernate-mapping>
<class name= "Parent" >
<id name= "id" >
<generator class= "sequence" />
</id>
<set name= "children" >
<key column= "parent_id" not-null= "true" />
<one-to-many class= "Child" />
</set>
</class>
<class name= "Child" >
<id name= "id" >
<generator class= "sequence" />
</id>
<property name= "name" />
</class>
</hibernate-mapping> ]]></programlisting>
<para >
另外一方面,如果一个子实例可能有多个父实例, 那么就应该使用many-to-many关联：
</para>
<programlisting > <![CDATA[<hibernate-mapping>
<class name= "Parent" >
<id name= "id" >
<generator class= "sequence" />
</id>
<set name= "children" table= "childset" >
<key column= "parent_id" />
<many-to-many class= "Child" column= "child_id" />
</set>
</class>
<class name= "Child" >
<id name= "id" >
<generator class= "sequence" />
</id>
<property name= "name" />
</class>
</hibernate-mapping> ]]></programlisting>
<para >
表定义：
</para>
<programlisting > < ![CDATA[create table parent ( id bigint not null primary key )
create table child ( id bigint not null primary key, name varchar(255) )
create table childset ( parent_id bigint not null,
child_id bigint not null,
primary key ( parent_id, child_id ) )
alter table childset add constraint childsetfk0 (parent_id) references parent
alter table childset add constraint childsetfk1 (child_id) references child]]></programlisting>
<para >
更多的例子,以及一个完整的父/子关系映射的排练,请参阅<xref linkend= "example-parentchild" /> .
</para>
<para >
甚至可能出现更加复杂的关联映射,我们会在下一章中列出所有可能性。
</para>
</sect1>
</chapter>
