集合类(Collections)映射

zhanglingsi

浏览: 91732 次
性别:
来自: 深圳

最近访客更多访客>>

u012363178

开山怪

odexuce

Coande

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Hibernate

Hibernate SQL Access JDK

Hibernate要求持久化集合值字段必须声明为接口，比如：

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

实际的接口可能是java.util.Set, java.util.Collection, java.util.List, java.util.Map, java.util.SortedSet, java.util.SortedMap 或者...任何你喜欢的类型！("任何你喜欢的类型" 代表你需要编写 org.hibernate.usertype.UserCollectionType的实现.)

注意我们是如何用一个HashSet实例来初始化实例变量的.这是用于初始化新创建(尚未持久化)的类实例中集合值属性的最佳方法。当你持久化这个实例时——比如通过调用persist()——Hibernate 会自动把HashSet替换为Hibernate自己的Set实现。观察下面的错误：

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!

根据不同的接口类型，被Hibernate注射的持久化集合类的表现类似HashMap, HashSet, TreeMap, TreeSet or ArrayList。

集合类实例具有值类型的通常行为。当被持久化对象引用后，他们会自动被持久化，当不再被引用后，自动被删除。假若实例被从一个持久化对象传递到另一个，它的元素可能从一个表转移到另一个表。两个实体不能共享同一个集合类实例的引用。因为底层关系数据库模型的原因，集合值属性无法支持空值语义；Hibernate对空的集合引用和空集合不加区别。

你不需要过多的为此担心。就如同你平时使用普通的Java集合类一样来使用持久化集合类。只是要确认你理解了双向关联的语义（后文讨论）。

7.2. 集合映射（ Collection mappings ）

用于映射集合类的Hibernate映射元素取决于接口的类型。比如， <set> 元素用来映射Set类型的属性。

<class name="Product">
<id name="serialNumber" column="productSerialNumber"/>
<set name="parts">
<key column="productSerialNumber" not-null="true"/>
<one-to-many class="Part"/>
</set>
</class>

除了<set>,还有<list>, <map>, <bag>, <array> 和 <primitive-array> 映射元素。<map>具有代表性：

<map
name="propertyName"                                         (1)
table="table_name"                                          (2)
schema="schema_name"                                        (3)
lazy="true|false"                                           (4)
inverse="true|false"                                        (5)
cascade="all|none|save-update|delete|all-delete-orphan"     (6)
sort="unsorted|natural|comparatorClass"                     (7)
order-by="column_name asc|desc"                             (8)
where="arbitrary sql where condition"                       (9)
fetch="join|select|subselect"                               (10)
batch-size="N"                                              (11)
access="field|property|ClassName"                           (12)
optimistic-lock="true|false"                                (13)
node="element-name|."
embed-xml="true|false"
>
<key .... />
<map-key .... />
<element .... />
</map>

(1)	`name` 集合属性的名称
(2)	`table` （可选——默认为属性的名称）这个集合表的名称(不能在一对多的关联关系中使用)
(3)	`schema` (可选) 表的schema的名称, 他将覆盖在根元素中定义的schema
(4)	`lazy` (可选--默认为true) 可以用来关闭延迟加载，指定一直使用预先抓取（对数组不适用）
(5)	`inverse` (可选——默认为`false`) 标记这个集合作为双向关联关系中的方向一端。
(6)	`cascade` (可选——默认为`none`) 让操作级联到子实体
(7)	`sort`(可选)指定集合的排序顺序, 其可以为自然的(`natural`)或者给定一个用来比较的类。
(8)	`order-by` (可选, 仅用于jdk1.4) 指定表的字段(一个或几个)再加上asc或者desc(可选), 定义Map,Set和Bag的迭代顺序
(9)	`where` (可选) 指定任意的SQL where条件, 该条件将在重新载入或者删除这个集合时使用(当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常有用)
(10)	`fetch` (可选, 默认为`select`) 用于在外连接抓取、通过后续select抓取和通过后续subselect抓取之间选择。
(11)	`batch-size` (可选, 默认为`1`) 指定通过延迟加载取得集合实例的批处理块大小（"batch size"）。
(12)	`access`(可选-默认为属性property):Hibernate取得属性值时使用的策略
(12)	`乐观锁` (可选 - 默认为 `true`): 对集合的状态的改变会是否导致其所属的实体的版本增长。 (对一对多关联来说，关闭这个属性常常是有理的)

7.2.1. 集合外键(Collection foreign keys)

集合实例在数据库中依靠持有集合的实体的外键加以辨别。此外键作为集合关键字段（collection key column）（或多个字段）加以引用。集合关键字段通过<key> 元素映射。

在外键字段上可能具有非空约束。对于大多数集合来说，这是隐含的。对单向一对多关联来说，外键字段默认是可以为空的，因此你可能需要指明 not-null="true"。

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

外键约束可以使用ON DELETE CASCADE。

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

对<key> 元素的完整定义，请参阅前面的章节。

7.2.2. 集合元素（Collection elements）

集合几乎可以包含任何其他的Hibernate类型，包括所有的基本类型、自定义类型、组件，当然还有对其他实体的引用。存在一个重要的区别：位于集合中的对象可能是根据“值”语义来操作（其声明周期完全依赖于集合持有者），或者它可能是指向另一个实体的引用，具有其自己的生命周期。在后者的情况下，被作为集合持有的状态考虑的，只有两个对象之间的“连接”。

被包容的类型被称为集合元素类型（collection element type）。集合元素通过<element>或<composite-element>映射，或在其是实体引用的时候，通过<one-to-many> 或<many-to-many>映射。前两种用于使用值语义映射元素，后两种用于映射实体关联。

7.2.3. 索引集合类(Indexed collections)

所有的集合映射，除了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"/>

(1)	`column`(可选):保存集合索引值的字段名。
(2)	`formula` (可选): 用于计算map关键字的SQL公式
(3)	`type` (可选,默认为整型`integer`):集合索引的类型。

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

(1)	`column`(可选):集合索引值中外键字段的名称
(2)	`formula` (可选): 用于计算map关键字的外键的SQL公式
(3)	`class` (必需):集合的索引使用的实体类。

假若你的表没有一个索引字段,当你仍然希望使用List作为属性类型,你应该把此属性映射为Hibernate <bag>。从数据库中获取的时候，bag不维护其顺序，但也可选择性的进行排序。

从集合类可以产生很大一部分映射，覆盖了很多常见的关系模型。我们建议你试验schema生成工具，来体会一下不同的映射声明是如何被翻译为数据库表的。

7.2.4. 值集合于多对多关联(Collections of values and many-to-many associations)

任何值集合或者多对多关联需要专用的具有一个或多个外键字段的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"
/>

(1)	`column`(可选):保存集合元素值的字段名。
(2)	`formula` (可选): 用于计算元素的SQL公式
(3)	`type` (必需):集合元素的类型

多对多关联(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"
/>

(1)	`column`(可选): 这个元素的外键关键字段名
(2)	`formula` (可选): 用于计算元素外键值的SQL公式.
(3)	`class` (必需): 关联类的名称
(3)	`outer-join` (可选 - 默认为`auto`): 在Hibernate系统参数中`hibernate.use_outer_join`被打开的情况下,该参数用来允许使用outer join来载入此集合的数据。
(4)	为此关联打开外连接抓取或者后续select抓取。这是特殊情况；对于一个实体及其指向其他实体的多对多关联进全预先抓取（使用一条单独的`SELECT`)，你不仅需要对集合自身打开`join`，也需要对`<many-to-many>`这个内嵌元素打开此属性。
(5)	对外键字段允许DDL生成的时候生成一个惟一约束。这使关联变成了一个高效的一对多关联。（此句存疑：原文为This makes the association multiplicity effectively one to many.)
(6)	`not-found` (可选 - 默认为 `exception`): 指明引用的外键中缺少某些行该如何处理： `ignore` 会把缺失的行作为一个空引用处理。
(7)	`entity-name` (可选): 被关联的类的实体名，作为`class`的替代。

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

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

7.2.5. 一对多关联（One-to-many Associations）

一对多关联通过外键连接两个类对应的表,而没有中间集合表。这个关系模型失去了一些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"
/>

(1)	`class`(必须):被关联类的名称。
(2)	`not-found` (可选 - 默认为`exception`): 指明若缓存的标示值关联的行缺失,该如何处理: `ignore` 会把缺失的行作为一个空关联处理。
(3)	`entity-name` (可选): 被关联的类的实体名，作为`class`的替代。

例子

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

7.3. 高级集合映射（Advanced collection mappings）

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

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

7.3.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="eg.Child">
<id name="id" column="id"/>
....
<many-to-one name="parent"
class="Parent"
column="parent_id"
not-null="true"/>
</class>

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

7.3.3. 三重关联（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>

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

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

7.3.4. `使用<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="eg.Person" outer-join="true"/>
</idbag>

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

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

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

7.4. 集合例子（Collection example）

在前面的几个章节的确非常令人迷惑。因此让我们来看一个例子。这个类：

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; }
....
....
}

这个类有一个Child的实例集合。如果每一个子实例至多有一个父实例, 那么最自然的映射是一个one-to-many的关联关系：

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

在以下的表定义中反应了这个映射关系：

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

如果父亲是必须的, 那么就可以使用双向one-to-many的关联了：

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

请注意NOT NULL的约束:

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

另外，如果你绝对坚持这个关联应该是单向的，你可以对<key>映射声明NOT NULL约束：

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

另外一方面,如果一个子实例可能有多个父实例, 那么就应该使用many-to-many关联：

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

表定义：

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

分享到：

对象/关系数据库映射基础 | Hibernate包作用详解

2008-06-16 16:45
浏览 931
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论