让我们从一个简单的例子开始，假设要实现一个从类Parent到类Child的一对多关系。

<set name="children">
    <key column="parent_id"/>
    <one-to-many class="Child"/>
</set>

如果我们运行下面的代码

Parent p = new Parent ();
Child c = new Child();
p.getChildren().add(c);
session.save(c);
session.flush();

Hibernate就会产生下面的两条SQL语句:

这样做不仅效率低，而且违反了列parent_id非空的限制。我们可以通过在集合类映射上指定not-null="true"来解决非空约束的冲突：

<set name="children">
    <key column="parent_id" not-null="true"/>
    <one-to-many class="Child"/>
</set>

当然，这并非是推荐的解决方法。

底层的原因是，对象p到对象c的连接（外键parent_id）没有被当作是Child对象状态的一部分，也没有在INSERT的时候被创建。解决的办法是，在Child一端设置映射。

<many-to-one name="parent" column="parent_id" not-null="true"/>

（我们还需要为类Child添加parent属性）

现在实体Child在管理连接的状态，为了使collection不更新连接，我们使用inverse属性。

<set name="children" inverse="true">
    <key column="parent_id"/>
    <one-to-many class="Child"/>
</set>

下面的代码是用来添加一个新的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();

现在，只会有一条INSERT语句被执行！

为了让事情变得井井有条，可以为Parent加一个addChild()方法。

public void addChild(Child c) ...{
    c.setParent(this);
    children.add(c);
}

现在，添加Child的代码就是这样

Parent p = (Parent) session.load(Parent.class, pid);
Child c = new Child();
p.addChild(c);
session.save(c);
session.flush();

你看，代码是不是简洁明了了很多呢？

对每个对象调用save()方法很麻烦，我们可以用级联来解决这个问题。

<set name="children" inverse="true" cascade="all">
    <key column="parent_id"/>
    <one-to-many class="Child"/>
</set>

配置级联以后，代码就可以这样写：

Parent p = (Parent) session.load(Parent.class, pid);
Child c = new Child();
p.addChild(c);
session.flush();

同样的，保存或删除Parent对象的时候并不需要遍历其子对象。 下面的代码会删除对象p及其所有子对象对应的数据库记录。

Parent p = (Parent) session.load(Parent.class, pid);
session.delete(p);
session.flush();

然而，这段代码

Parent p = (Parent) session.load(Parent.class, pid);
Child c = (Child) p.getChildren().iterator().next();
p.getChildren().remove(c);
c.setParent(null);
session.flush();

不会从数据库删除c；它只会删除与p之间的连接（并且会导致违反NOT NULL约束，在这个例子中）。你需要明确调用Child的delete()方法。

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中移除，实际上我们是想删除它。要实现这种要求，就必须使用cascade="all-delete-orphan"。

<set name="children" inverse="true" cascade="all-delete-orphan">
    <key column="parent_id"/>
    <one-to-many class="Child"/>
</set>

注意：即使在collection一方的映射中指定inverse="true"，在遍历collection的时候级联操作仍然会执行。如果你想要通过级联进行子对象的插入、删除、更新操作，就必须把它加到collection中，只调用setParent()是不够的。

假设我们从Session中装入了一个Parent对象，用户界面对其进行了修改，然后我们希望在一个新的Session里面调用update()来更新它。对象Parent包含了子对象的集合，由于打开了级联更新，Hibernate需要知道哪些子对象是新的，哪些是数据库中已经存在的。我们假设Parent和Child对象的标识属性都是自动生成的，类型为java.lang.Long。Hibernate会使用标识属性的值，和version 或 timestamp 属性，来判断哪些子对象是新的，在 Hibernate3 中,显式指定unsaved-value不再是必须的了。

下面的代码会更新parent和child对象，并且插入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();

好的，对于自动生成标识的情况这样做很方便，但是自分配的标识和复合标识怎么办呢？这是有点麻烦，因为Hibernate没有办法区分新对象（标识被用户指定了）和前一个Session装入的对象。在这种情况下，Hibernate会使用timestamp或version属性，或者查询第二级缓存，或者最坏的情况，查询数据库，来确认是否此行存在。

这个问题往往让新手感到迷惑，它确实不太容易消化。不过，经过一些实践以后，你会感觉越来越顺手。父子对象模式已经被广泛的应用在Hibernate应用程序中。