306 lines
14 KiB
XML
306 lines
14 KiB
XML
<chapter id="example-parentchild">
|
||
<title>示例：父子关系(Parent Child Relationships)</title>
|
||
<para>
|
||
刚刚接触Hibernate的人大多是从父子关系（parent / child type relationship）的建模入手的。父子关系的建模有两种方法。由于种种原因，最方便的方法是把<literal>Parent</literal>和<literal>Child</literal>都建模成实体类，并创建一个从<literal>Parent</literal>指向<literal>Child</literal>的<one-to-many>关联，对新手来说尤其如此。还有一种方法，就是将<literal>Child</literal>声明为一个<literal><composite-element></literal>（组合元素）。 事实上在Hibernate中one to many关联的默认语义远没有composite element贴近parent / child关系的通常语义。下面我们会阐述如何使用<emphasis>带有级联的双向一对多关联(bidirectional one to many association with cascades)</emphasis>去建立有效、优美的parent / child关系。这一点也不难！
|
||
</para>
|
||
|
||
<sect1 id="example-parentchild-collections">
|
||
<title>关于collections需要注意的一点</title>
|
||
<para>
|
||
Hibernate collections被当作其所属实体而不是其包含实体的一个逻辑部分。这非常重要！它主要体现为以下几点：
|
||
</para>
|
||
<itemizedlist>
|
||
<listitem>
|
||
<para>
|
||
当删除或增加collection中对象的时候，collection所属者的版本值会递增。
|
||
</para>
|
||
</listitem>
|
||
<listitem>
|
||
<para>
|
||
如果一个从collection中移除的对象是一个值类型(value type)的实例，比如composite element，那么这个对象的持久化状态将会终止，其在数据库中对应的记录会被删除。同样的，向collection增加一个value type的实例将会使之立即被持久化。
|
||
</para>
|
||
</listitem>
|
||
<listitem>
|
||
<para>
|
||
另一方面，如果从一对多或多对多关联的collection中移除一个实体，在缺省情况下这个对象并不会被删除。这个行为是完全合乎逻辑的－－改变一个实体的内部状态不应该使与它关联的实体消失掉！同样的，向collection增加一个实体不会使之被持久化。
|
||
</para>
|
||
</listitem>
|
||
</itemizedlist>
|
||
|
||
<para>
|
||
实际上，向Collection增加一个实体的缺省动作只是在两个实体之间创建一个连接而已，同样移除的时候也只是删除连接。这种处理对于所有的情况都是合适的。对于父子关系则是完全不适合的，在这种关系下，子对象的生存绑定于父对象的生存周期。
|
||
</para>
|
||
|
||
</sect1>
|
||
<sect1 id="example-parentchild-bidir">
|
||
<title>双向的一对多关系(Bidirectional one-to-many)</title>
|
||
|
||
<para>
|
||
假设我们要实现一个简单的从Parent到Child的<one-to-many>关联。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[<set name="children">
|
||
<key column="parent_id"/>
|
||
<one-to-many class="Child"/>
|
||
</set>]]></programlisting>
|
||
|
||
<para>
|
||
如果我们运行下面的代码
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = .....;
|
||
Child c = new Child();
|
||
p.getChildren().add(c);
|
||
session.save(c);
|
||
session.flush();]]></programlisting>
|
||
|
||
<para>
|
||
Hibernate会产生两条SQL语句：
|
||
</para>
|
||
|
||
<itemizedlist>
|
||
<listitem>
|
||
<para>一条<literal>INSERT</literal>语句，为<literal>c</literal>创建一条记录</para>
|
||
</listitem>
|
||
<listitem>
|
||
<para>
|
||
一条<literal>UPDATE</literal>语句，创建从<literal>p</literal>到<literal>c</literal>的连接
|
||
</para>
|
||
</listitem>
|
||
</itemizedlist>
|
||
|
||
<para>
|
||
这样做不仅效率低，而且违反了列<literal>parent_id</literal>非空的限制。我们可以通过在集合类映射上指定<literal>not-null="true"</literal>来解决违反非空约束的问题：
|
||
</para>
|
||
|
||
<programlisting><![CDATA[<set name="children">
|
||
<key column="parent_id" not-null="true"/>
|
||
<one-to-many class="Child"/>
|
||
</set>]]></programlisting>
|
||
|
||
<para>
|
||
然而，这并非是推荐的解决方法。
|
||
</para>
|
||
|
||
<para> 这种现象的根本原因是从<literal>p</literal>到<literal>c</literal>的连接（外键parent_id）没有被当作<literal>Child</literal>对象状态的一部分，因而没有在INSERT语句中被创建。因此解决的办法就是把这个连接添加到Child的映射中。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[<many-to-one name="parent" column="parent_id" not-null="true"/>]]></programlisting>
|
||
|
||
<para>
|
||
（我们还需要为类<literal>Child</literal>添加<literal>parent</literal>属性）
|
||
</para>
|
||
|
||
<para>
|
||
现在实体<literal>Child</literal>在管理连接的状态，为了使collection不更新连接，我们使用<literal>inverse</literal>属性。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[<set name="children" inverse="true">
|
||
<key column="parent_id"/>
|
||
<one-to-many class="Child"/>
|
||
</set>]]></programlisting>
|
||
|
||
<para>
|
||
下面的代码是用来添加一个新的<literal>Child</literal>
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
Child c = new Child();
|
||
c.setParent(p);
|
||
p.getChildren().add(c);
|
||
session.save(c);
|
||
session.flush();]]></programlisting>
|
||
|
||
<para>
|
||
现在，只会有一条<literal>INSERT</literal>语句被执行！
|
||
</para>
|
||
|
||
<para>
|
||
为了让事情变得井井有条，可以为<literal>Parent</literal>加一个<literal>addChild()</literal>方法。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[public void addChild(Child c) {
|
||
c.setParent(this);
|
||
children.add(c);
|
||
}]]></programlisting>
|
||
|
||
<para>
|
||
现在，添加<literal>Child</literal>的代码就是这样
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
Child c = new Child();
|
||
p.addChild(c);
|
||
session.save(c);
|
||
session.flush();]]></programlisting>
|
||
|
||
</sect1>
|
||
|
||
<sect1 id="example-parentchild-cascades">
|
||
<title>级联生命周期（Cascading lifecycle）</title>
|
||
<para>
|
||
需要显式调用<literal>save()</literal>仍然很麻烦，我们可以用级联来解决这个问题。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[<set name="children" inverse="true" cascade="all">
|
||
<key column="parent_id"/>
|
||
<one-to-many class="Child"/>
|
||
</set>]]></programlisting>
|
||
|
||
<para>
|
||
这样上面的代码可以简化为：
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
Child c = new Child();
|
||
p.addChild(c);
|
||
session.flush();]]></programlisting>
|
||
|
||
<para>
|
||
同样的，保存或删除<literal>Parent</literal>对象的时候并不需要遍历其子对象。
|
||
下面的代码会删除对象<literal>p</literal>及其所有子对象对应的数据库记录。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
session.delete(p);
|
||
session.flush();]]></programlisting>
|
||
|
||
<para>
|
||
然而，这段代码
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
Child c = (Child) p.getChildren().iterator().next();
|
||
p.getChildren().remove(c);
|
||
c.setParent(null);
|
||
session.flush();]]></programlisting>
|
||
|
||
<para>
|
||
不会从数据库删除<literal>c</literal>；它只会删除与<literal>p</literal>之间的连接（并且会导致违反<literal>NOT NULL</literal>约束，在这个例子中）。你需要显式调用<literal>delete()</literal>来删除<literal>Child</literal>。 <!--，因为Hibernate并没有设计垃圾回收器！代码如下：-->
|
||
</para>
|
||
|
||
<programlisting><![CDATA[Parent p = (Parent) session.load(Parent.class, pid);
|
||
Child c = (Child) p.getChildren().iterator().next();
|
||
p.getChildren().remove(c);
|
||
session.delete(c);
|
||
session.flush();]]></programlisting>
|
||
|
||
|
||
<para>
|
||
在我们的例子中，如果没有父对象，子对象就不应该存在，如果将子对象从collection中移除，实际上我们是想删除它。要实现这种要求，就必须使用<literal>cascade="all-delete-orphan"</literal>。
|
||
</para>
|
||
|
||
|
||
<programlisting><![CDATA[<set name="children" inverse="true" cascade="all-delete-orphan">
|
||
<key column="parent_id"/>
|
||
<one-to-many class="Child"/>
|
||
</set>]]></programlisting>
|
||
|
||
<para>
|
||
注意：即使在collection一方的映射中指定<literal>inverse="true"</literal>，级联仍然是通过遍历collection中的元素来处理的。如果你想要通过级联进行子对象的插入、删除、更新操作，就必须把它加到collection中，只调用<literal>setParent()</literal>是不够的。
|
||
</para>
|
||
|
||
</sect1>
|
||
|
||
<sect1 id="example-parentchild-update">
|
||
<title>级联与<literal>未保存值</literal>（Cascades and <literal>unsaved-value</literal>）</title>
|
||
|
||
<para>
|
||
假设我们从<literal>Session</literal>中装入了一个<literal>Parent</literal>对象，用户界面对其进行了修改，然后希望在一个新的Session里面调用<literal>update()</literal>来保存这些修改。对象<literal>Parent</literal>包含了子对象的集合，由于打开了级联更新，Hibernate需要知道哪些Child对象是新实例化的，哪些代表数据库中已经存在的记录。我们假设<literal>Parent</literal>和<literal>Child</literal>对象的标识属性都是自动生成的，类型为<literal>java.lang.Long</literal>。Hibernate会使用标识属性的值，和version 或 timestamp 属性，来判断哪些子对象是新的。(参见<xref linkend="objectstate-saveorupdate"/>.) <emphasis>在 Hibernate3 中,显式指定<literal>unsaved-value</literal>不再是必须的了。</emphasis>
|
||
</para>
|
||
|
||
<para>
|
||
下面的代码会更新<literal>parent</literal>和<literal>child</literal>对象，并且插入<literal>newChild</literal>对象。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[//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();]]></programlisting>
|
||
|
||
<para>
|
||
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.
|
||
</para>
|
||
<para>
|
||
这对于自动生成标识的情况是非常好的，但是自分配的标识和复合标识怎么办呢？这是有点麻烦，因为Hibernate没有办法区分新实例化的对象（标识被用户指定了）和前一个Session装入的对象。在这种情况下，Hibernate会使用timestamp或version属性，或者查询第二级缓存，或者最坏的情况，查询数据库，来确认是否此行存在。</para>
|
||
|
||
<!-- undocumenting
|
||
|
||
<para>
|
||
还有一种可能情况，有一个名为<literal>isUnsaved()</literal>的<literal>新的拦截器（Interceptor）</literal>方法，它允许应用程序自己实现新实例的判断。比如，你可以自己定义一个持久类的祖先类：
|
||
</para>
|
||
|
||
<programlisting><![CDATA[public class Persistent {
|
||
private boolean _saved = false;
|
||
public void onSave() {
|
||
_saved=true;
|
||
}
|
||
public void onLoad() {
|
||
_saved=true;
|
||
}
|
||
......
|
||
public boolean isSaved() {
|
||
return _saved;
|
||
}
|
||
}]]></programlisting>
|
||
|
||
<para>
|
||
（<literal>saved</literal>属性是不会被持久化的。)
|
||
现在在<literal>onLoad()</literal>和<literal>onSave()</literal>外，还要实现<literal>isUnsaved()</literal>。
|
||
</para>
|
||
|
||
<programlisting><![CDATA[public Boolean isUnsaved(Object entity) {
|
||
if (entity instanceof Persistent) {
|
||
return new Boolean( !( (Persistent) entity ).isSaved() );
|
||
}
|
||
else {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
public boolean onLoad(Object entity,
|
||
Serializable id,
|
||
Object[] state,
|
||
String[] propertyNames,
|
||
Type[] types) {
|
||
|
||
if (entity instanceof Persistent) ( (Persistent) entity ).onLoad();
|
||
return false;
|
||
}
|
||
|
||
public boolean onSave(Object entity,
|
||
Serializable id,
|
||
Object[] state,
|
||
String[] propertyNames,
|
||
Type[] types) {
|
||
|
||
if (entity instanceof Persistent) ( (Persistent) entity ).onSave();
|
||
return false;
|
||
}]]></programlisting>
|
||
|
||
<para>
|
||
Don't worry; in Hibernate3 you don't need to write any of this kind of code if you don't want to.
|
||
别担心，在Hibernate3中，假若你不愿意，你不需要编写任何这类代码。
|
||
</para>
|
||
-->
|
||
|
||
</sect1>
|
||
|
||
|
||
<sect1 id="example-parentchild-conclusion">
|
||
<title>结论</title>
|
||
<para> 这里有不少东西需要融会贯通，可能会让新手感到迷惑。但是在实践中它们都工作地非常好。大部分Hibernate应用程序都会经常用到父子对象模式。
|
||
</para>
|
||
<para>
|
||
在第一段中我们曾经提到另一个方案。上面的这些问题都不会出现在<literal><composite-element></literal>映射中，它准确地表达了父子关系的语义。很不幸复合元素还有两个重大限制:复合元素不能拥有collections，并且，除了用于惟一的父对象外，它们不能再作为其它任何实体的子对象。
|
||
</para>
|
||
</sect1>
|
||
|
||
</chapter> |