精通hibernate学习笔记（3）[关联关系]

关联关系分：单向关联（一对多、多对一）和双向关联（一对多双向）

在关系数据库中，只存在外键参照关系，而且总是由“many”方参照“one”方，因为这样才能消除数据冗余，因此关系数据库实际上只支持多对一或一对一的单项关联。

1、单向关联及级联保存和更新

Order和Customer存在多对一的关系，在Order映射文件中可以设置为：

<many-to-one

name="customer"

column="CUSTOMER_ID"

class="mypack.Customer"

not-null="true"/>

存在这样的使用方法：

Customercustomer=newCustomer("Jack");

//session.save(customer);

Orderorder1=newOrder("Jack_Order001",customer);

Orderorder2=newOrder("Jack_Order002",customer);

session.save(order1);//抛出PropertyValueException异常

session.save(order2);

抛出异常的原因：

save(order1)时，因为customer没有被持久化（在这种设置情况下，HIbernate不会自动持久化Customer对象），所以对应的customerId=null，当保存时<many-to-one>设置customer中的customerId为not-null，所以会出现异常。如果设置not-null="false",也会抛出异常：TransientObjectException，原因是order1的customer属性引用了一个临时对象Customer。

如果使用级联保存和更新那么可以解决这个问题：

<many-to-one

name="customer"

column="CUSTOMER_ID"

class="mypack.Customer"

cascade="save-update"

not-null="true"/>

这样Hibernate会自动持久化关联的临时对象。

2、映射一对多双向关联

既然是双向关联，实际上一对多还是多对一都是一回事，只是一对多比较顺口！

1中在Order中有了customer属性（多对一关系），可以直接在Order对象中获得所属的Customer，如果想知道该order所属的Customer的所有order，那么还需要通过一次查询才能获得。如果在Customer中添加Customer对Order的一对多关系，设为orders属性，那么就可以方便实现上述功能，调用getOrders()方法即可，这就形成了双向关联。

注：Hibernate要求在持久化类中定义集合类属性时，必须把属性声明为接口类型，如：java.util.set、java.util.Map、java.util.List。这样可以提高持久化类的透明性。

在定义集合属性时，通常把他初始化为集合实现类的一个实例，privateSetorders=newHashSet();这样可以提高程序的健壮性，避免因为null而抛出异常。

映射方法：

<setname="orders"cascade="save-update">

<keycolumn="CUSTOMER_ID"/>

<one-to-manyclass="myapck.Order"/>

</set>

当建立order对象和customer对象的双向关联关系时，需要在程序中同时修改两个对象的属性：

-建立Order到Customer对象的多对一关系

order.setCustomer(customer)

hibernate探测到这个变化后会将order对应的CUSTOMER_ID的值改为customer的id，会执行SQL：

updateORDERSsetORDER_NUMBER="Jack_Order001",CUSTOMER_ID=2whereID=2;

-建立Customer对象到Order对象的一对多关联关系：

customer.getOrders().addOrder(order);

hibernate探测到这个变化后也会将order对应的CUSTOMER_ID的值改为customer的id，会执行SQL：

updateORDERSsetCUSTOMER_ID=2whereID=2;

这样会重复执行多余的SQL，影响性能。解决这一问题的方法是把<set>元素的inverse属性设置为true,默认为false;

<setname="orders"cascade="save-update"inverse="true">

<keycolumn="CUSTOMER_ID"/>

<one-to-manyclass="myapck.Order"/>

</set>

这样设置以后，如果只执行：order.setCustomer(customer)，同样会自动更新order记录

但是如果只执行：customer.getOrders().addOrder(order);却不会自动更新order记录，这是因为在Customer对象的orders属性映射中<set>元素设置了inverse=true;所以hibernate不会同步更新数据库：

结论：

--在映射一对多的双向关联关系时，应该在“many”方(orders属性)把inverse属性设置为"true",这样可以提高应用的性能。

--在建立两个对象的双向关联时，应该同时修改关联两端的对象的相应属性：

customer.getOrders().addOrder(order);

order.setCustomer(customer)

同理，解除双向关联的关系时，也应该修改关联两端的对象的属性：

customer.getOrders().remove(order);

order.setCustomer(null);

------------------------------------------------------------------------------------------------------------

多对一（many-to-one）

通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外键引用目标表的主键字段。

<many-to-one

name="propertyName"

column="column_name"

class="ClassName"

cascade="cascade_style"

fetch="join|select"

update="true|false"

insert="true|false"

property-ref="propertyNameFromAssociatedClass"

access="field|property|ClassName"

unique="true|false"

not-null="true|false"

optimistic-lock="true|false"

lazy="proxy|no-proxy|false"

not-found="ignore|exception"

entity-name="EntityName"

formula="arbitrarySQLexpression"

node="element-name|@attribute-name|element/@attribute|."

embed-xml="true|false"

index="index_name"

unique_key="unique_key_id"

foreign-key="foreign_key_name"

/>

1

name:属性名。

2

column(可选):外间字段名。它也可以通过嵌套的<column>元素指定。

3

class(可选-默认是通过反射得到属性类型):关联的类的名字。

4

cascade（级联）(可选):指明哪些操作会从父对象级联到关联的对象。

5

fetch(可选-默认为select):在外连接抓取（outer-joinfetching）和序列选择抓取（sequentialselectfetching）两者中选择其一。

6

update,insert(可选-默认为true)指定对应的字段是否包含在用于UPDATE和/或INSERT的SQL语句中。如果二者都是false,则这是一个纯粹的“外源性（derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他属性得到或者通过trigger(触发器）、或其他程序生成。

6

property-ref:(可选)指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。

7

access(可选-默认是property):Hibernate用来访问属性的策略。

8

unique(可选):使用DDL为外键字段生成一个唯一约束。此外，这也可以用作property-ref的目标属性。这使关联同时具有一对一的效果。

9

not-null(可选):使用DDL为外键字段生成一个非空约束。

10

optimistic-lock(可选-默认为true):指定这个属性在做更新时是否需要获得乐观锁定（optimisticlock）。换句话说，它决定这个属性发生脏数据时版本（version）的值是否增长。

11

lazy(可选-默认为proxy):默认情况下，单点关联是经过代理的。lazy="no-proxy"指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetchelazily）（需要运行时字节码的增强）。lazy="false"指定此关联总是被预先抓取。

12

not-found(可选-默认为exception):指定外键引用的数据不存在时如何处理：ignore会将行数据不存在视为一个空（null）关联。

13

entity-name(可选):被关联的类的实体名。

14

formula(可选):SQL表达式，用于定义computed（计算出的）外键值。

cascade属性设置为除了none以外任何有意义的值，它将把特定的操作传递到关联对象中。这个值就代表着Hibernate基本操作的名称，persist,merge,delete,save-update,evict,replicate,lock,refresh，以及特别的值delete-orphan和all，并且可以用逗号分隔符来组合这些操作，例如，cascade="persist,merge,evict"或cascade="all,delete-orphan"。更全面的解释请参考第10.11节“传播性持久化(transitivepersistence)”.注意，单值关联(many-to-one和one-to-one关联)不支持删除孤儿（orphandelete，删除不再被引用的值）.

一个典型的简单many-to-one定义例子：

<many-to-onename="product"class="Product"column="PRODUCT_ID"/>

property-ref属性只应该用来对付遗留下来的数据库系统，可能有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。这是一种十分丑陋的关系模型。比如说，假设Product类有一个惟一的序列号，它并不是主键。（unique属性控制Hibernate通过SchemaExport工具进行的DDL生成。）

<propertyname="serialNumber"unique="true"type="string"column="SERIAL_NUMBER"/>

那么关于OrderItem的映射可能是：

<many-to-onename="product"property-ref="serialNumber"column="PRODUCT_SERIAL_NUMBER"/>

当然，我们决不鼓励这种用法。

如果被引用的唯一主键由关联实体的多个属性组成，你应该在名称为<properties>的元素里面映射所有关联的属性。

假若被引用的唯一主键是组件的属性，你可以指定属性路径：

<many-to-onename="owner"property-ref="identity.ssn"column="OWNER_SSN"/>

------------------------------------------------------------------------------------------------------------

3、级联删除

如果在删除customer的时候，将其关联的orders也删除只需要设置cascade=delete

<setname="orders"casecade="delete"inverse="true">

<keycolumn="CUSTOMER_ID"/>

<one-to-manyclass="myapck.Order"/>

</set>

4、父子关系

解除customer与其中一个order之间的关系：

tx=session.beginTransaction();

Customercustomer=(Customer>session.load(Customer.class,newLong(2));

Orderorder=(Order)customer.getOrders().iterator().next();

customer.getOrders().remove(order);

order.setCustover(null);

tx.commit();

如果cascade取默认值“none”，当order.setCustomer(null)时，会执行：

updateORDERSsetCUSTOMER_ID=nullwhereID=2;

如果希望Hiernate自动删除不再和customer对象关联的order对象，可以把cascade属性设置为"all-delete-orphan"

<setname="orders"cascade="all-delete-orphan"inverse="true">

<keycolumn="CUSTOMER_ID"/>

<one-to-manyclass="myapck.Order"/>

</set>

此时如果执行order.setCustomer(null)会执行一下SQL:

deletefromORDERSwhereCUSTOMER_ID=2andID=2；

cascade="all-delete-orphan"时Hibernate会按以下方式处理Customer对象：

--当保存或更新Customer对象时，级联保存或更新所有关联的Order对象，相当于cascade="save-update"

--当删除Customer对象时，级联删除所有关联的Order对象，相当于cascade="delete"

--删除不再和Customer对象关联的所有Order对象。

总结：

当关联双方存在父子方系，就可以把父方的cascade属性设置为"all-delete-orphan"。所谓父子关系，是指由父方来控制子方的持久化生命周期，子方对象必须和一个父方对象关联。如果删除父方对象，应该级联删除所有的关联子方对象，如果一个子方对象不再和一个父方对象关联，应该把这个子方对象删除。

5、一对多双向自身关联关系

考虑以下情形：Category表

每个Category可能有其（0或1个）父类和（多个子类），其映射文件如下：

<?xmlversion="1.0"?>

<!DOCTYPEhibernate-mapping

PUBLIC"-//Hibernate/HibernateMappingDTD2.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>

<classname="mypack.Category"table="CATEGORIES">

<idname="id"type="long"column="ID">

<generatorclass="increment"/>

</id>

<propertyname="name"type="string">

<columnname="NAME"length="15"/>

</property>

<set

name="childCategories"

cascade="save-update"

inverse="true"

>

<keycolumn="CATEGORY_ID"/>

<one-to-manyclass="mypack.Category"/>

</set>

<many-to-one

name="parentCategory"

column="CATEGORY_ID"

class="mypack.Category"

/>

</class>

</hibernate-mapping>

表数据：

父类别的映射为：

<many-to-one

name="parentCategory"

column="CATEGORY_ID"

class="mypack.Category"

/>

原理：

<many-to-one>表示多个该类对象对应一个父类别。[以外键匹配主键]

<many-to-one>元素表示以"CATEGORY_ID"作为外键与"mypack.Category"对应的表的主键去匹配，如果存在则是父类别。

如：表中的food，CATEGORY_ID=null所以没有父类别，与图相符，vegetable和fruit的父类是food;

子类别的映射：

<set

name="childCategories"

cascade="save-update"

inverse="true"

>

<keycolumn="CATEGORY_ID"/>

<one-to-manyclass="mypack.Category"/>

</set>

原理：

<one-to-many>表示单个该类对象对应多个子类别；[以主键去匹配外键]

<one-to-many>元素表示以该记录对应的表的主键（ID）去匹配"mypack.Category"对应的表中的"CATEGORY_ID"字段；