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

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

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

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

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

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

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

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

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

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

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

對于一個值集合, 我們使用<element>標簽。

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

多對多關聯(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>

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

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

一個實體數組,在這個案例中是一個多對多的關聯(注意這里的實體是自動管理生命周期的對象（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>

一對多關聯通過外鍵連接兩個類對應的表,而沒有中間集合表。 這個關系模型失去了一些Java集合的語義:

一個從Product到Part的關聯需要關鍵字字段,可能還有一個索引字段指向Part所對應的表。 <one-to-many>標記指明了一個一對多的關聯。

<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>元素不需要定義任何字段。 也不需要指定表名。

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

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

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

Hibernate支持實現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和某個實現了java.util.Comparator的類的名稱。

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

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

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

關聯還可以在運行時使用集合filter()根據任意的條件來排序。

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

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

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

這里有一個many-to-many的雙向關聯的例子;每一個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>

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

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

非反向端用于把內存中的表示保存到數據庫中。

要建立一個一對多的雙向關聯，你可以通過把一個一對多關聯，作為一個多對一關聯映射到到同一張表的字段上，并且在"多"的那一端定義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"不會影響級聯操作，二者是正交的概念！

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

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

第二種方法是簡單的把關聯重新建模為一個實體類。這使我們最經常使用的方法。

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

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

<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生成器，就好像是實體類一樣！集合的每一行都有一個不同的人造關鍵字。但是，Hibernate沒有提供任何機制來讓你取得某個特定行的人造關鍵字。

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

在目前的實現中，還不支持使用identity標識符生成器策略來生成<idbag>集合的標識符。