This chapter describes how to gather performance metrics for the use of Hibernate in the field. Specific attention is giving to key areas like collections and lazy loading of data.
2?a >Using Coherence and Hibernate
3?a >Ehcache
4?a >http://swik.net/cache
5?a >Speed Up Your Hibernate Applications with Second-Level Caching
]]>
<?xml version="1.0" encoding="UTF-8"?>
<templates><template name="@hib-blob-byte" description="blob to byte" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.property column="${enclosing_method}" type="org.springframework.orm.hibernate3.support.BlobByteArrayType" lazy="true" </template><template name="@hib-class" description="@hibernate.class" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.class table="${enclosing_type}" dynamic-update="true"</template><template name="@hib-class-disc" description="@hibernate.discriminator" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.discriminator column="type" type="character" not-null="true" force="false"</template><template name="@hib-class-join" description="hibernate join subclass" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.joined-subclass table="${primary_type_name}" lazy="true" dynamic-update="true"
*@hibernate.joined-subclass-key column="${primary_type_name}Guid" * *请修改子cȝ表名Q对应表的主键，该主键不需要定义在cȝ属性中Q它对应父类的主?amp;#13;
</template><template name="@hib-class-sub" description="@hibernate.subclass" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.subclass name="${file}" discriminator-value=""</template><template name="@hib-id-assign" description="id is assign" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.id generator-class="assigned" length="20" column="请修? </template><template name="@hib-id-guid" description="id is guid" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.id generator-class="uuid" type="java.lang.String"
* @hibernate.column name="guid" sql-type="VARCHAR(38)" not-null="true" *
* 请修改name of column的?lt;/template><template name="@hib-rel-many-to-many-list" description="many to many list" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.list name="Ҏ名（无GetQ? inverse="true" cascade="save-update"
* lazy="true"
* @hibernate.collection-key column="外键"
* @hibernate.collection-index column="tabIndex" type="int"
* @hibernate.collection-one-to-many class="兌的类"
*
* 请修改外键，q且指定完整的关联类的类名（?cdQ?lt;/template><template name="@hib-rel-many-to-many-set" description="many 2 many set" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.set name="${enclosing_method}" table="兌? cascade="save-update" inverse="true" lazy="true" * @hibernate.collection-key column="自己的主? * @hibernate.collection-many-to-many class="兌c? column="兌cȝ主键" * * 两个cȝ主键构成兌表的属性，兌c请写完整的cd * 多对多时Q只能指定一个多的方向断子ؓtrueQ即inverse="true" * 多对多时Q无法指定index序Q因Z无法定从两个方向看上去都具有顺序，所以用List不可?amp;#13;</template><template name="@hib-rel-many-to-one" description="@hibernate.many-to-one" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.many-to-one column="${enclosing_method}_ID" class="${return_type}" cascade="none" outer-join="auto" not-null="false" lazy="true"
* * Lclass指定完整的包?cd
* @return ${return_type}
*</template><template name="@hib-rel-one-to-many-list" description="@hibernate.one-to-many relationship" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.list name="${enclosing_method}" inverse="true" cascade="save-update" lazy="true" * @hibernate.collection-key column="外键" * @hibernate.collection-index column="TABINDEX" type="int" * @hibernate.collection-one-to-many class="兌的类" * * 请修改外键，q且指定完整的关联类的类名（?cdQ?amp;#13;</template><template name="@hib-rel-one-to-many-set" description="one 2 many set" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.set name="${enclosing_method}" inverse="true" cascade="save-update" lazy="true"
* @hibernate.collection-key column="外键"
* @hibernate.collection-one-to-many class="兌的类"
*
* 请修改外键，q且指定完整的关联类的类名（?cdQ?amp;#13;
</template><template name="@hib-rel-parent-child-list" description="one to mang [construct a tree]" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.list lazy="true" inverse="true" cascade="all"
* @hibernate.collection-key column="parentGuid"
* @hibernate.collection-index column="tabIndex"
* @hibernate.collection-one-to-many class="${enclosing_package}.${primary_type_name}"
*
* 请修改collection-keyQ它是many方的外键
* tabIndex可以修改Q也可以不修改，而且cM不必要一定有q个属性存在，因ؓ它是Hib在操作List旉要的一个属性，只需数据库中定义了即可?amp;#13;
</template><template name="@hib-string-clob" description="hibernate string to clob" context="javadoc" enabled="true" deleted="false" autoinsert="true">@hibernate.property name="${enclosing_method}" column="ORG_Description" type="org.springframework.orm.hibernate3.support.ClobStringType" not-null="false" unique="false" length="4000" </template></templates>
如何倒入参考随W?br> 代码实例Q?br> /**
* @hibernate.id generator-class="uuid" type="java.lang.String"
* name="guid" column="A_GUID" length="38"
*
*/
public java.lang.String getGuid() {
return orgGuid;
}
private Set childDepartment;
/**
* @hibernate.set lazy="false" cascade="all" lazy="true"
* @hibernate.collection-key column="Superior_GUID"
* @hibernate.collection-one-to-many class="model.Department"
*
* @return Set
*/
public Set getChildDepartment() {
return childDepartment;
}
public void setChildDepartment(Set childDepartment) {
this.childDepartment = childDepartment;
}
private Set roles;
/**
* many to may
*
* @hibernate.set name="roles" table="ORG_DEPT_REF_ROLE"
* cascade="save-update" inverse="true" lazy="true"
* @hibernate.collection-key column="DEPT_GUID"
* @hibernate.collection-many-to-many class="model.Role"
* column="ROLE_GUID"
* @return Set
*/
public Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
private List positions;
/**
*
* @hibernate.list name="positions" inverse="true" cascade="save-update"
* lazy="true"
* @hibernate.collection-key column="DEPT_GUID"
* @hibernate.collection-index column="POSITION_TABINDEX" type="int"
* @hibernate.collection-one-to-many class="model.Position"
*
* 请修改外键，q且指定完整的关联类的类名（?cdQ?br> */
public List getPositions() {
return positions;
}
public void setPositions(List positions) {
this.positions = positions;
}
]]>
一、引用Huihoo译Hibernate官方文档
2.3. W二部分 Q?兌映射
我们已经映射了一个持久化实体cd一个表上。让我们在这个基上增加一些类之间的关联性? 首先我们往我们E序里面增加人（peopleQ的概念Qƈ存储他们所参与的一个Event列表? Q译者注Q与Event一P我们在后面的教程中将直接使用person来表C“h”而不是它的中文翻译）
最初的PersoncL单的Q?
public class Person {
private Long id;
private int age;
private String firstname;
private String lastname;
Person() {}
// Accessor methods for all properties, private setter for 'id'
}Create a new mapping file called Person.hbm.xml:
<hibernate-mapping>
<class name="Person" table="PERSON">
<id name="id" column="PERSON_ID">
<generator class="increment"/>
</id>
<property name="age"/>
<property name="firstname"/>
<property name="lastname"/>
</class>
</hibernate-mapping>
Finally, add the new mapping to Hibernate's configuration:
<mapping resource="Event.hbm.xml"/>
<mapping resource="Person.hbm.xml"/>
我们现在在q两个实体类之间创徏一个关联。显Ӟperson可以参与一pdEventQ而Event也有不同的参加者（personQ? 设计上面我们需要考虑的问题是兌的方向（directionalityQ，阶数QmultiplicityQ和集合QcollectionQ的行ؓ?
我们向Personcd加一lEvent。这h们可以轻杄通过调用aPerson.getEvents() 得到一个Person所参与的Event列表Q而不必执行一个显式的查询。我们用一个Java的集合类Q一?tt class="literal">SetQ因为Set 不允许包括重复的元素而且排序和我们无兟?
目前为止我们设计了一个单向的Q在一端有许多g之对应的兌Q通过Set来实现? 让我们ؓq个在Javac里~码q映这个关联：
public class Person {
private Set events = new HashSet();
public Set getEvents() {
return events;
}
public void setEvents(Set events) {
this.events = events;
}
}在我们映这个关联之前，先考虑q个兌另外一端。很昄的，我们可以保持q个兌是单向的。如果我们希望这个关联是双向的， 我们可以?tt class="literal">Event里创建另外一个集合，例如Q?tt class="literal">anEvent.getParticipants()? q是留给你的一个设计选项Q但是从q个讨论中我们可以很清楚的了解什么是兌的阶敎ͼmultiplicityQ：在这个关联的两端都是“多”? 我们叫这个ؓQ?span class="emphasis">多对多（many-to-manyQ?/em>兌。因此，我们使用Hibernate的many-to-many映射Q?
<class name="Person" table="PERSON">
<id name="id" column="PERSON_ID">
<generator class="increment"/>
</id>
<property name="age"/>
<property name="firstname"/>
<property name="lastname"/>
<set name="events" table="PERSON_EVENT">
<key column="PERSON_ID"/>
<many-to-many column="EVENT_ID" class="Event"/>
</set>
</class>
Hibernate支持所有种cȝ集合映射Q?tt class="literal"><set>是最普遍被用的。对于多对多Qmany-to-manyQ关?或者叫n:m实体关系), 需要一个用来储存关联的表（association tableQ?tt class="literal">?/tt>里面的每一行代表从一个personC个event的一个关联? 表名是由set元素?tt class="literal">table属性值配|的。关联里面的标识字段名，person的一端，? ?tt class="literal"><key>元素定义Qevent一端的字段名是?tt class="literal"><many-to-many>元素? column属性定义的。你也必d诉Hibernate集合中对象的c（也就是位于这个集合所代表的关联另外一端的c）?
q个映射的数据库表定义如下：
_____________ __________________
| | | | _____________
| EVENTS | | PERSON_EVENT | | |
|_____________| |__________________| | PERSON |
| | | | |_____________|
| *EVENT_ID | <--> | *EVENT_ID | | |
| EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID |
| TITLE | |__________________| | AGE |
|_____________| | FIRSTNAME |
| LASTNAME |
|_____________|
让我们把一些people和event攑ֈEventManager的一个新Ҏ中：
private void addPersonToEvent(Long personId, Long eventId) {
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
Person aPerson = (Person) session.load(Person.class, personId);
Event anEvent = (Event) session.load(Event.class, eventId);
aPerson.getEvents().add(anEvent);
tx.commit();
HibernateUtil.closeSession();
}在加载一?tt class="literal">Person和一?tt class="literal">Event之后Q简单的使用普通的Ҏ修改集合? 如你所见，没有昑ּ?tt class="literal">update()或?tt class="literal">save(), Hibernate自动到集合已经被修? q要保存。这个叫?span class="emphasis">automatic dirty checkingQ你也可以尝试修改Q何对象的name或者date的参数? 只要他们处于persistent状态，也就是被l定在某个Hibernate Session上（例如Q他? 刚刚在一个单元操作从被加载或者保存）QHibernate监视M改变q在后台隐式执行SQL。同步内存状态和数据库的q程Q通常只在 一个单元操作结束的时候发生，q个q程被叫?span class="emphasis">flushing?
你当然也可以在不同的单元操作里面加蝲person和event。或者在一?tt class="literal">Session以外修改一? 不是处在持久化（persistentQ状态下的对象（如果该对象以前曾l被持久化，我们U这个状态ؓqQdetachedQ?/em>Q? 在程序里Q看h像下面这P
private void addPersonToEvent(Long personId, Long eventId) {
Session session = HibernateUtil.currentSession();
Transaction tx = session.beginTransaction();
Person aPerson = (Person) session.load(Person.class, personId);
Event anEvent = (Event) session.load(Event.class, eventId);
tx.commit();
HibernateUtil.closeSession();
aPerson.getEvents().add(anEvent); // aPerson is detached
Session session2 = HibernateUtil.currentSession();
Transaction tx2 = session.beginTransaction();
session2.update(aPerson); // Reattachment of aPerson
tx2.commit();
HibernateUtil.closeSession();
}
?tt class="literal">update的调用一个脱对象（detached objectQ重新持久化Q你可以说它被绑定到 一个新的单元操作上Q所以Q何你对它在脱（detachedQ状态下所做的修改都会被保存到数据库里?
q个Ҏ们当前的情Ş不是很有用，但是它是非常重要的概念，你可以把它设计进你自qE序中。现在，加进一个新? 选项?tt class="literal">EventManager的mainҎ中，q从命o行运行它来完成这个练习。如果你需要一个person? 一个event的标识符 Q?save()q回它?******q最后一句看不明?
上面是一个关于两个同{地位的c间兌的例子，q是在两个实体之间。像前面所提到的那P也存在其它的特别的类和类型，q些cdcd通常是“次要的”? 其中一些你已经看到q，好像int或?tt class="literal">String。我们称D些类?span class="emphasis">值类型（value typeQ?/em>, 它们的实?span class="emphasis">依赖QdependQ?/em>在某个特定的实体上。这些类型的实例没有自己的n份（identityQ，也不能在实体间共? Q比如两个person不能引用同一?tt class="literal">firstname对象Q即使他们有相同的名字）。当Ӟvalue typesq不仅仅在JDK中存? Q事实上Q在一个HibernateE序中，所有的JDKc都被视为值类型）Q你也可以写你自q依赖c，例如AddressQ? MonetaryAmount?
你也可以设计一个值类型的集合Qcollection of value typesQ，q个在概念上与实体的集合有很大的不同Q但是在Java里面看v来几乎是一L?
我们把一个值类型对象的集合加入Person。我们希望保存email地址Q所以我们?tt class="literal">StringQ? 而这ơ的集合cd又是SetQ?
private Set emailAddresses = new HashSet();
public Set getEmailAddresses() {
return emailAddresses;
}
public void setEmailAddresses(Set emailAddresses) {
this.emailAddresses = emailAddresses;
}
Set的映?
<set name="emailAddresses" table="PERSON_EMAIL_ADDR">
<key column="PERSON_ID"/>
<element type="string" column="EMAIL_ADDR"/>
</set>
比较q次和较早先的映，差别主要?tt class="literal">element部分q次q没有包括对其它实体cd的引用，而是使用一个元素类型是 String的集合（q里使用写的名字是向你表明它是一个Hibernate的映类型或者类型{换器Q? 和以前一Pset?tt class="literal">table参数军_用于集合的数据库表名?tt class="literal">key元素 定义了在集合表中使用的外键?tt class="literal">element元素?tt class="literal">column参数定义实际保存String? 的字D名?
看一下修改后的数据库表定义?
_____________ __________________
| | | | _____________
| EVENTS | | PERSON_EVENT | | | ___________________
|_____________| |__________________| | PERSON | | |
| | | | |_____________| | PERSON_EMAIL_ADDR |
| *EVENT_ID | <--> | *EVENT_ID | | | |___________________|
| EVENT_DATE | | *PERSON_ID | <--> | *PERSON_ID | <--> | *PERSON_ID |
| TITLE | |__________________| | AGE | | *EMAIL_ADDR |
|_____________| | FIRSTNAME | |___________________|
| LASTNAME |
|_____________|
你可以看到集合表Qcollection tableQ的主键实际上是个复合主键，同时使用?个字Dc这也暗CZ对于同一? person不能有重复的email地址Q这正是Java里面使用Set时候所需要的语义QSet里元素不能重复）?
你现在可以试着把元素加入这个集合，像我们在之前关联person和event的那栗Java里面的代码是相同的?
下面我们映一个双向关联（bi-directional associationQ－ 在Java里面让person和event可以从关联的 M一端访问另一端。当Ӟ数据库表定义没有改变Q我们仍焉要多对多Qmany-to-manyQ的阶数QmultiplicityQ。一个关pd数据库要比网l编E语a 更加灉|Q所以它q不需要Q何像D方向Qnavigation directionQ的东西 Q?数据可以用Q何可能的方式q行查看和获取?
首先Q把一个参与者（personQ的集合加入EventcMQ?
private Set participants = new HashSet();
public Set getParticipants() {
return participants;
}
public void setParticipants(Set participants) {
this.participants = participants;
}
?tt class="literal">Event.hbm.xml里面也映这个关联?
<set name="participants" table="PERSON_EVENT" inverse="true">
<key column="EVENT_ID"/>
<many-to-many column="PERSON_ID" class="Person"/>
</set>
如你所见，2个映文仉都有通常?tt class="literal">set映射。注?tt class="literal">key?tt class="literal">many-to-many 里面的字D名在两个映文件中是交换的。这里最重要的不同是Event映射文g?tt class="literal">set元素? inverse="true"参数?
q个表示Hibernate需要在两个实体间查扑օ联信息的时候，应该使用兌的另外一?Q?PersoncR? q将会极大的帮助你理解双向关联是如何在我们的两个实体间创建的?
首先Q请牢记在心QHibernateq不影响通常的Java语义? 在单向关联中Q我们是怎样在一?tt class="literal">Person和一?tt class="literal">Event之间创徏联系的？ 我们把一?tt class="literal">Event的实例加C?tt class="literal">Personcd的Event集合里。所以，昄如果我们要让q个兌可以双向工作Q? 我们需要在另外一端做同样的事?Q??tt class="literal">Person加到一?tt class="literal">Eventcd的Person集合中? q“在兌的两端设|联pZ是l对必要的而且你永q不应该忘记做它?
许多开发者通过创徏理兌的方法来保证正确的设|了兌的两端，比如?tt class="literal">Person里：
protected Set getEvents() {
return events;
}
protected void setEvents(Set events) {
this.events = events;
}
public void addToEvent(Event event) {
this.getEvents().add(event);
event.getParticipants().add(this);
}
public void removeFromEvent(Event event) {
this.getEvents().remove(event);
event.getParticipants().remove(this);
}注意现在对于集合的get和setҎ的访问控制别是protected - q允许在位于同一个包QpackageQ中的类以及l承自这个类的子c? 可以讉Kq些ҎQ但是禁止其它的直接外部讉KQ避免了集合的内容出现乱。你应该可能的在集合所对应的另外一端也q样做?
inverse映射参数I竟表示什么呢Q对于你和对于Java来说Q一个双向关联仅仅是在两端简单的讄引用。然而仅仅这? Hibernateq没有够的信息L的产生INSERT?tt class="literal">UPDATE语句Q以避免q反数据库约束）Q? 所以Hibernate需要一些帮助来正确的处理双向关联。把兌的一端设|ؓinverse告诉Hibernate忽略兌? q一端，把这端看成是另外一端的一?span class="emphasis">镜子QmirrorQ?/em>。这是Hibernate所需的信息，Hibernate用它来处理如何把? 一个数据导航模型映到关系数据库表定义? 你仅仅需要记住下面这个直观的规则Q所有的双向兌需要有一端被讄?tt class="literal">inverse。在一个一对多Qone-to-manyQ关联中 它必L代表多（manyQ的那端。而在多对多（many-to-manyQ关联中Q你可以L选取一端，两端之间q没有差别?/font>
22.1. 关于collections需要注意的一?/font>
Hibernate collections被当作其所属实体而不是其包含实体的一个逻辑部分。这非常重要Q它主要体现Z下几点：
当删除或增加collection中对象的时候，collection所属者的版本g递增?
如果一个从collection中移除的对象是一个值类?value type)的实例，比如composite elementQ那么这个对象的持久化状态将会终止，其在数据库中对应的记录会被删除。同LQ向collection增加一个value type的实例将会之立卌持久化?
另一斚wQ如果从一对多或多对多兌的collection中移除一个实体，在缺省情况下q个对象q不会被删除。这个行为是完全合乎逻辑的－Q改变一个实 体的内部状态不应该使与它关联的实体消失掉！同样的，向collection增加一个实体不会之被持久化?
实际上，向Collection增加一个实体的~省动作只是在两个实体之间创Z个连接而已Q同L除的时候也只是删除q接。这U处理对于所有的情况都是合适的。对于父子关pd是完全不适合的，在这U关pMQ子对象的生存绑定于父对象的生存周期?
假设我们要实C个简单的从Parent到Child?lt;one-to-many>兌?
<set name="children">
<key column="parent_id"/>
<one-to-many class="Child"/>
</set>
如果我们q行下面的代?
Parent p = .....;
Child c = new Child();
p.getChildren().add(c);
session.save(c);
session.flush();
Hibernate会生两条SQL语句Q?
一?tt class="literal">INSERT语句Qؓc创徏一条记?/font>
一?tt class="literal">UPDATE语句Q创Zp?tt class="literal">c的连?
q样做不仅效率低Q而且q反了列parent_id非空的限制。我们可以通过在集合类映射上指?tt class="literal">not-null="true"来解册反非I约束的问题Q?
<set name="children">
<key column="parent_id" not-null="true"/>
<one-to-many class="Child"/>
</set>
然而，qƈ非是推荐的解x法?
q种现象的根本原因是?tt class="literal">p?tt class="literal">c的连接（外键parent_idQ没有被当作Child对象状态的一部分Q因而没有在INSERT语句中被创徏。因此解决的办法是把这个连接添加到Child的映中?
<many-to-one name="parent" column="parent_id" not-null="true"/>
Q我们还需要ؓc?tt class="literal">Childdparent属性）
现在实体Child在管理连接的状态，Z使collection不更新连接，我们使用inverse属性?
<set name="children" inverse="true">
<key column="parent_id"/>
<one-to-many class="Child"/>
</set>
下面的代码是用来d一个新?tt class="literal">Child
Parent p = (Parent) session.load(Parent.class, pid);
Child c = new Child();
c.setParent(p);
p.getChildren().add(c);
session.save(c);
session.flush();
现在Q只会有一?tt class="literal">INSERT语句被执行！
Z让事情变得井井有条，可以?tt class="literal">Parent加一?tt class="literal">addChild()Ҏ?
public void addChild(Child c) {
c.setParent(this);
children.add(c);
}现在Q添?tt class="literal">Child的代码就是这?
Parent p = (Parent) session.load(Parent.class, pid);
Child c = new Child();
p.addChild(c);
session.save(c);
session.flush();
需要显式调?tt class="literal">save()仍然很麻烦，我们可以用联来解决q个问题?
<set name="children" inverse="true" cascade="all">
<key column="parent_id"/>
<one-to-many class="Child"/>
</set>
q样上面的代码可以简化ؓQ?
Parent p = (Parent) session.load(Parent.class, pid);
Child c = new Child();
p.addChild(c);
session.flush();
同样的，保存或删?tt class="literal">Parent对象的时候ƈ不需要遍历其子对象? 下面的代码会删除对象p及其所有子对象对应的数据库记录?
Parent p = (Parent) session.load(Parent.class, pid);
session.delete(p);
session.flush();
然而，q段代码
Parent p = (Parent) session.load(Parent.class, pid);
Child c = (Child) p.getChildren().iterator().next();
p.getChildren().remove(c);
c.setParent(null);
session.flush();
不会从数据库删除cQ它只会删除?tt class="literal">p之间的连接（q且会导致违?tt class="literal">NOT NULLU束Q在q个例子中）。你需要显式调?tt class="literal">delete()来删?tt class="literal">Child?
Parent p = (Parent) session.load(Parent.class, pid);
Child c = (Child) p.getChildren().iterator().next();
p.getChildren().remove(c);
session.delete(c);
session.flush();
在我们的例子中，如果没有父对象，子对象就不应该存在，如果子对象从collection中移除，实际上我们是惛_除它。要实现q种要求Q就必须使用cascade="all-delete-orphan"?
<set name="children" inverse="true" cascade="all-delete-orphan">
<key column="parent_id"/>
<one-to-many class="Child"/>
</set>
注意Q即使在collection一方的映射中指?tt class="literal">inverse="true"Q联仍然是通过遍历collection中的元素来处理的。如果你惌通过U联q行子对象的插入、删除、更新操作，必L它加到collection中，只调?tt class="literal">setParent()是不够的?
假设我们?tt class="literal">Session中装入了一?tt class="literal">Parent对象Q用L面对其进行了修改Q然后希望在一个新的Session里面调用update()来保存这些修攏V对?tt class="literal">Parent包含了子对象的集合，׃打开了联更斎ͼHibernate需要知道哪些Child对象是新实例化的Q哪些代表数据库中已l存在的记录。我们假?tt class="literal">Parent?tt class="literal">Child对象的标识属性都是自动生成的Q类型ؓjava.lang.Long。Hibernate会用标识属性的|和version ?timestamp 属性，来判断哪些子对象是新的?参见?Hibernate3 ?昑ּ指定unsaved-value不再是必ȝ了?/em>
下面的代码会更新parent?tt class="literal">child对象Qƈ且插?tt class="literal">newChild对象?
//parent and child were both loaded in a previous session
parent.addChild(child);
Child newChild = new Child();
parent.addChild(newChild);
session.update(parent);
session.flush();
Well, that's all very well for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate can't use the identifier property to distinguish between a newly instantiated object (with an identifier assigned by the user) and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists.
q对于自动生成标识的情况是非常好的，但是自分配的标识和复合标识怎么办呢Q这是有炚w烦，因ؓHibernate没有办法区分新实例化的对象（标识被用 h定了Q和前一个Session装入的对象。在q种情况下，Hibernate会用timestamp或version属性，或者查询第二~存Q或 者最坏的情况Q查询数据库Q来认是否此行存在?/font>
1、inversecMUML图中的导向?one-manyӞ如果你设计的cL先整体，后部分，那么整体一端应该inverse为true?br> many-manyӞ如果其中一端是业务语义的根Q另一端的存在依附于根Q那么根q一端的inverse为trueQ否则配|ؓfalse.如果两端都配|ؓtrueQ关联表中就无法写入数据Q如果两端都配置为falseQ你׃能同时a.addB(b),b.addA(a)的方式互相放入对方的集合中，否则会发生冲H?br>
2、Cascading配置了类之间的行为媄响程度。本文引用的W二大节讲的很清楚。在实际使用Ӟq是要注意其用法与业务的兌Q?br> 如果只删除关联关p，通常配置save-update / none
如果把子端全部删除，配置为all?br>
3、Set在用时。many-one,删除oneӞcascading必须为all。如果是save-update,none都会出现“违反完整约束条件”的错误?br> many-manyQA-B)ӞA方cascading为allӞ删除Ac，B、AB兌信息都会被删除?br> A方cascading为save-updateӞ删除Ac，AB兌信息会被删除QB保留?br> A方cascading为none?删除Ac，B、AB兌信息都会保留?br> 4、List使用Ӟ首先必须保index的值必设|，否则q背了List序位置的概念，无法完成删除逻辑的正性，且会throw“违反完整约束条件”的错误?br> 在正给定了index后，其行ZSet相同?br>
]]>
6.1.10.
多对一Qmany-to-oneQ?/span>
7.1.
持久化集合类(Persistent collections)
7.2.
集合映射Q?Collection mappings Q?/span>
7.2.1.
集合外键(Collection foreign keys)
7.2.2.
集合?span lang="EN-US">素（Collection elementsQ?/span>
7.2.3.
索引集合c?Indexed collections)
7.2.4.
值集合于多对多关?Collections of values and
many-to-many associations)
7.2.5.
一对多兌QOne-to-many AssociationsQ?/span>
7.3.
高集合映射QAdvanced collection mappingsQ?/span>
7.3.1.
有序集合QSorted collectionsQ?/span>
7.3.2.
双向兌QBidirectional associationsQ?/span>
7.3.3.
三重兌QTernary associationsQ?/span>
7.4.
集合例子QCollection exampleQ?/span>
8.2.
单向兌QUnidirectional associationsQ?/span>
8.2.3.
一对多Qone to manyQ?/span>
8.3.
使用q接表的单向兌QUnidirectional associations with
join tablesQ?/span>
8.3.2.
多对一Qmany to oneQ?/span>
8.3.4.
多对多（many to manyQ?/span>
8.4.
双向兌QBidirectional associationsQ?/span>
8.4.1.
一对多Qone to many) / 多对一Qmany to oneQ?/span>
8.5.
使用q接表的双向兌QBidirectional associations with
join tablesQ?/span>
8.5.1.
一对多Qone to manyQ?/多对一Q?
many to oneQ?/span>
8.5.3.
多对多（many to manyQ?/span>
]]>
我们的学习步骤是Q?br> 1、理解OO概念
2、编写实体类
3、理解Hibernate兌映射
4、添加XDoclet标注
5、生成HbmQ编写JUnit试
6、测试SetӞinverse、cascating的媄响力
试ListӞinverse、cascating的媄响力
7、再读Hibernate官方文档Q深入理解之?br>
]]>