集合實例在數(shù)據(jù)庫中依靠持有集合的實體的外鍵加以辨別。此外鍵作為集合關(guān)鍵字段（collection key column）（或多個字段）加以引用。集合關(guān)鍵字段通過<key> 元素映射。

在外鍵字段上可能具有非空約束。對于大多數(shù)集合來說，這是隱含的。對單向一對多關(guān)聯(lián)來說，外鍵字段默認(rèn)是可以為空的，因此你可能需要指明 not-null="true"。

<key column="productSerialNumber" not-null="true"/>

外鍵約束可以使用ON DELETE CASCADE。

<key column="productSerialNumber" on-delete="cascade"/>

對<key> 元素的完整定義，請參閱前面的章節(jié)。

集合幾乎可以包含任何其他的Hibernate類型，包括所有的基本類型、自定義類型、組件，當(dāng)然還有對其他實體的引用。存在一個重要的區(qū)別：位于集合中的對象可能是根據(jù)“值”語義來操作（其聲明周期完全依賴于集合持有者），或者它可能是指向另一個實體的引用，具有其自己的生命周期。在后者的情況下，被作為集合持有的狀態(tài)考慮的，只有兩個對象之間的“連接”。

被包容的類型被稱為集合元素類型（collection element type）。集合元素通過<element>或<composite-element>映射，或在其是實體引用的時候，通過<one-to-many> 或<many-to-many>映射。前兩種用于使用值語義映射元素，后兩種用于映射實體關(guān)聯(lián)。

所有的集合映射，除了set和bag語義的以外，都需要指定一個集合表的索引字段(index column)——用于對應(yīng)到數(shù)組索引，或者List的索引，或者Map的關(guān)鍵字。通過<map-key>,Map 的索引可以是任何基礎(chǔ)類型；若通過<map-key-many-to-many>，它也可以是一個實體引用；若通過<composite-map-key>，它還可以是一個組合類型。數(shù)組或列表的索引必須是integer類型，并且使用 <list-index>元素定義映射。被映射的字段包含有順序排列的整數(shù)（默認(rèn)從0開始）。

<map-key
column="column_name"                (1)
formula="any SQL expression"        (2)
type="type_name"                    (3)
node="@attribute-name"
length="N"/>

<map-key-many-to-many
column="column_name"                (1)
formula="any SQL expression"        (2)(3)
class="ClassName"
/>

假若你的表沒有一個索引字段,當(dāng)你仍然希望使用List作為屬性類型,你應(yīng)該把此屬性映射為Hibernate <bag>。從數(shù)據(jù)庫中獲取的時候，bag不維護其順序，但也可選擇性的進行排序。

任何值集合或者多對多關(guān)聯(lián)需要專用的具有一個或多個外鍵字段的collection table、一個或多個collection element column，以及還可能有一個或多個索引字段。

對于一個值集合, 我們使用<element>標(biāo)簽。

<element
column="column_name"                     (1)
formula="any SQL expression"             (2)
type="typename"                          (3)
length="N"
precision="N"
scale="N"
not-null="true|false"
unique="true|false"
node="element-name"
/>

多對多關(guān)聯(lián)(many-to-many association) 使用 <many-to-many>元素定義.

<many-to-many
column="column_name"                               (1)
formula="any SQL expression"                       (2)
class="ClassName"                                  (3)
fetch="select|join"                                (4)
unique="true|false"                                (5)
not-found="ignore|exception"                       (6)
entity-name="EntityName"                           (7)
node="element-name"
embed-xml="true|false"
/>

例子：首先, 一組字符串：

<set name="names" table="NAMES">
<key column="GROUPID"/>
<element column="NAME" type="string"/>
</set>

包含一組整數(shù)的bag(還設(shè)置了order-by參數(shù)指定了迭代的順序)：

<bag name="sizes"
table="item_sizes"
order-by="size asc">
<key column="item_id"/>
<element column="size" type="integer"/>
</bag>

一個實體數(shù)組,在這個案例中是一個多對多的關(guān)聯(lián)(注意這里的實體是自動管理生命周期的對象（lifecycle objects）,cascade="all"):

<array name="addresses"
table="PersonAddress"
cascade="persist">
<key column="personId"/>
<list-index column="sortOrder"/>
<many-to-many column="addressId" class="Address"/>
</array>

一個map,通過字符串的索引來指明日期：

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

一個組件的列表：（下一章討論）

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

一對多關(guān)聯(lián)通過外鍵連接兩個類對應(yīng)的表,而沒有中間集合表。 這個關(guān)系模型失去了一些Java集合的語義:

一個從Product到Part的關(guān)聯(lián)需要關(guān)鍵字字段,可能還有一個索引字段指向Part所對應(yīng)的表。 <one-to-many>標(biāo)記指明了一個一對多的關(guān)聯(lián)。

<one-to-many
class="ClassName"                                  (1)
not-found="ignore|exception"                       (2)
entity-name="EntityName"                           (3)
node="element-name"
embed-xml="true|false"
/>

例子

<set name="bars">
<key column="foo_id"/>
<one-to-many class="org.hibernate.Bar"/>
</set>

注意:<one-to-many>元素不需要定義任何字段。 也不需要指定表名。

重要提示:如果一對多關(guān)聯(lián)中的外鍵字段定義成NOT NULL,你必須把<key>映射聲明為not-null="true",或者使用雙向關(guān)聯(lián)，并且標(biāo)明inverse="true"。參閱本章后面關(guān)于雙向關(guān)聯(lián)的討論。

下面的例子展示一個Part實體的map,把name作為關(guān)鍵字。( partName 是Part的持久化屬性)。注意其中的基于公式的索引的用法。

<map name="parts"
cascade="all">
<key column="productId" not-null="true"/>
<map-key formula="partName"/>
<one-to-many class="Part"/>
</map>

Hibernate支持實現(xiàn)java.util.SortedMap和java.util.SortedSet的集合。你必須在映射文件中指定一個比較器：

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

sort屬性中允許的值包括unsorted,natural和某個實現(xiàn)了java.util.Comparator的類的名稱。

分類集合的行為事實上象java.util.TreeSet或者java.util.TreeMap。

如果你希望數(shù)據(jù)庫自己對集合元素排序，可以利用set,bag或者map映射中的order-by屬性。這個解決方案只能在jdk1.4或者更高的jdk版本中才可以實現(xiàn)(通過LinkedHashSet或者 LinkedHashMap實現(xiàn))。 它是在SQL查詢中完成排序，而不是在內(nèi)存中。

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

注意: 這個order-by屬性的值是一個SQL排序子句而不是HQL的！

關(guān)聯(lián)還可以在運行時使用集合filter()根據(jù)任意的條件來排序。

sortedUsers = s.createFilter( group.getUsers(), "order by this.name" ).list();

雙向關(guān)聯(lián)允許通過關(guān)聯(lián)的任一端訪問另外一端。在Hibernate中, 支持兩種類型的雙向關(guān)聯(lián):

要建立一個雙向的多對多關(guān)聯(lián)，只需要映射兩個many-to-many關(guān)聯(lián)到同一個數(shù)據(jù)庫表中，并再定義其中的一端為inverse(使用哪一端要根據(jù)你的選擇，但它不能是一個索引集合)。

這里有一個many-to-many的雙向關(guān)聯(lián)的例子;每一個category都可以有很多items,每一個items可以屬于很多categories：

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

如果只對關(guān)聯(lián)的反向端進行了改變，這個改變不會被持久化。 這表示Hibernate為每個雙向關(guān)聯(lián)在內(nèi)存中存在兩次表現(xiàn),一個從A連接到B,另一個從B連接到A。如果你回想一下Java對象模型，我們是如何在Java中創(chuàng)建多對多關(guān)系的，這可以讓你更容易理解：

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

非反向端用于把內(nèi)存中的表示保存到數(shù)據(jù)庫中。

要建立一個一對多的雙向關(guān)聯(lián)，你可以通過把一個一對多關(guān)聯(lián)，作為一個多對一關(guān)聯(lián)映射到到同一張表的字段上，并且在"多"的那一端定義inverse="true"。

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

在“一”這一端定義inverse="true"不會影響級聯(lián)操作，二者是正交的概念！

有三種可能的途徑來映射一個三重關(guān)聯(lián)。第一種是使用一個Map，把一個關(guān)聯(lián)作為其索引：

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

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

第二種方法是簡單的把關(guān)聯(lián)重新建模為一個實體類。這使我們最經(jīng)常使用的方法。

最后一種選擇是使用復(fù)合元素，我們會在后面討論

如果你完全信奉我們對于“聯(lián)合主鍵（composite keys）是個壞東西”，和“實體應(yīng)該使用（無機的）自己生成的代用標(biāo)識符（surrogate keys）”的觀點，也許你會感到有一些奇怪，我們目前為止展示的多對多關(guān)聯(lián)和值集合都是映射成為帶有聯(lián)合主鍵的表的！現(xiàn)在，這一點非常值得爭辯；看上去一個單純的關(guān)聯(lián)表并不能從代用標(biāo)識符中獲得什么好處（雖然使用組合值的集合可能會獲得一點好處）。不過，Hibernate提供了一個（一點點試驗性質(zhì)的）功能，讓你把多對多關(guān)聯(lián)和值集合應(yīng)得到一個使用代用標(biāo)識符的表去。

<idbag> 屬性讓你使用bag語義來映射一個List (或Collection)。

<idbag name="lovers" table="LOVERS">
<collection-id column="ID" type="long">
<generator class="sequence"/>
</collection-id>
<key column="PERSON1"/>
<many-to-many column="PERSON2" class="eg.Person" outer-join="true"/>
</idbag>

你可以理解，<idbag>人工的id生成器，就好像是實體類一樣！集合的每一行都有一個不同的人造關(guān)鍵字。但是，Hibernate沒有提供任何機制來讓你取得某個特定行的人造關(guān)鍵字。

注意<idbag>的更新性能要比普通的<bag>高得多！Hibernate可以有效的定位到不同的行，分別進行更新或刪除工作，就如同處理一個list, map或者set一樣。

在目前的實現(xiàn)中，還不支持使用identity標(biāo)識符生成器策略來生成<idbag>集合的標(biāo)識符。