解读Hibernate高级集合映射

本文主要介绍Hibernate高级集合映射（Advanced collection mappings），Hibernate高级集合映射主要分为有序集合、双向关联、双向关联，涉及有序集合类、 三重关联（Ternary associations）、使用<idbag>。

1. 有序集合（Sorted collections）

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()根据任意的条件来排序。

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

2. 双向关联（Bidirectional associations）

双向关联允许通过关联的任一端访问另外一端。在Hibernate中, 支持两种类型的双向关联:

◆一对多（one-to-many）
Set或者bag值在一端, 单独值(非集合)在另外一端

◆多对多（many-to-many）
两端都是set或bag值

要建立一个双向的多对多关联，只需要映射两个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="Child"> 
    <id name="id" column="child_id"/> 
    ....  
    <many-to-one name="parent"   
        class="Parent"   
        column="parent_id" 
        not-null="true"/> 
</class> 

在“一”这一端定义inverse="true"不会影响级联操作，二者是正交的概念！

3. 双向关联，涉及有序集合类

对于有一端是<list>或者<map>的双向关联，需要加以特别考虑。假若子类中的一个属性映射到索引字段，没问题，我们仍然可以在集合类映射上使用inverse="true"：

<class name="Parent"> 
    <id name="id" column="parent_id"/> 
    ....  
    <map name="children" inverse="true"> 
        <key column="parent_id"/> 
        <map-key column="name"   
            type="string"/> 
        <one-to-many class="Child"/> 
    </map> 
</class> 
 
<class name="Child"> 
    <id name="id" column="child_id"/> 
    ....  
    <property name="name"   
        not-null="true"/> 
    <many-to-one name="parent"   
        class="Parent"   
        column="parent_id" 
        not-null="true"/> 
</class> 

但是，假若子类中没有这样的属性存在，我们不能认为这个关联是真正的双向关联（信息不对称，在关联的一端有一些另外一端没有的信息）。在这种情况下，我们不能使用inverse="true"。我们需要这样用：

<class name="Parent"> 
    <id name="id" column="parent_id"/> 
    ....  
    <map name="children"> 
        <key column="parent_id" 
            not-null="true"/> 
        <map-key column="name"   
            type="string"/> 
        <one-to-many class="Child"/> 
    </map> 
</class> 
 
<class name="Child"> 
    <id name="id" column="child_id"/> 
    ....  
    <many-to-one name="parent"   
        class="Parent"   
        column="parent_id" 
        insert="false" 
        update="false" 
        not-null="true"/> 
</class> 

注意在这个映射中，关联中集合类"值"一端负责来更新外键.TODO: Does this really result in some unnecessary update statements?

4. 三重关联（Ternary associations）

有三种可能的途径来映射一个三重关联。***种是使用一个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> 

第二种方法是简单的把关联重新建模为一个实体类。这使我们最经常使用的方法。

***一种选择是使用复合元素，我们会在后面讨论

5. 使用<idbag>

如果你完全信奉我们对于“联合主键（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="Person" fetch="join"/> 
</idbag> 

你可以理解，<idbag>人工的id生成器，就好像是实体类一样！集合的每一行都有一个不同的人造关键字。但是，Hibernate没有提供任何机制来让你取得某个特定行的人造关键字。

注意<idbag>的更新性能要比普通的<bag>高得多！Hibernate可以有效的定位到不同的行，分别进行更新或删除工作，就如同处理一个list, map或者set一样。

在目前的实现中，还不支持使用identity标识符生成器策略来生成<idbag>集合的标识符。

【编辑推荐】

1. Hibernate乐观并发控制
2. Hibernate传播性持久化攻略
3. 深入了解Hibernate自动状态检测
4. 简单学会Hibernate对象持久化
5. 分析Hibernate自增主键