构造这样一个例子，在测试过程中来说明一些Hibernate的高级配置及其相关机制：
有三个类：Category.java,Prodcuct.java,ConfigurationTest.java，其中第三个类是用来测试的。
Category.java代码：
package unsaved_value;
import ......
public class Category {
private Integer id;
private String name;
private String description;
private Set products;
public Category(){
id=null;
name=null;
description=null;
products=new HashSet ();
}
public void addProduct(Product p){
products.add(p);
}
//**********setter and getter
........
}
Product.java代码：
package unsaved_value;
public class Product {
private Integer id;
private String name;
private Category category;
private String description;
public Product(){
}
//*******getter and setter
.........
}
ConfigurationTest.java
public void testSave()throws Exception{
Category category=new Category();
category.setName("java编程书籍2");
category.setDescription("编程经典书籍2");
Product pro=new Product();
pro.setName("java编程思想2");
pro.setDescription("第四版中文版2");
pro.setCategory(category);
category.addProduct(pro);
Transaction tx=session.beginTransaction();
assert (session!=null):("session is null");
session.save(category);
tx.commit();
}
Category代表产品目录，而Product代表产品，显然Category与Product是一对多的关系。Hibernate在映射一对多关系时，有两种方式，一种是单向一对多，一种是双向关系。两者相比，双向一对多的好处体现在两方面：首先，也是很明显的一点，由于是双向关联，我们在实际业务逻辑时将更方便，例如我们可以检索一个Category下的所有Product，同时还可以检索出Product属于哪个。其次，双向关系相对单向关系而言，在数据库的访问方面更有优势。这一点留在后面讲inverse时讲
。双向关联比单向关联唯一的”劣势“，就在于双向关联需要比单向关联多写一个映射文件，这不问题。使用双向关联实现这两个类同数据库的映射：
Category.hbm.xml:
version="1.0" encoding="UTF-8"?>
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="unsaved_value">
<class name="Category" table="category">
<id name="id" column="id">
<generator class="native">generator>
id>
<property name="name" column="name"/>
<property name="description" column="description"/>
<set name="products" table="product" lazy="true" inverse="true" cascade="all">
<key column="category"/>
<one-to-many class="Product"/>
set>
class>
hibernate-mapping>
Product.hbm.xml:
version="1.0" encoding="UTF-8"?>
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="unsaved_value">
<class name="Product" table="product">
<id name="id" column="id" unsaved-value="null">
<generator class="native">generator>
id>
<property name="name" column="name"/>
<property name="description" column="description"/>
<many-to-one name="category"
column="category"
class="Category"
/>
class>
hibernate-mapping>
现在把这个例子所牵涉到的知识一一展开：
一.inverse
该词的译意是“反转”,反转什么——反转控制端，这项配置决定了由关联双方中的哪一方来维持关联关系（在数据库中表现为外键约束）。上述配置中，在Category.hbm.xml中将inverse设置为true,意思是说“我需要反转（控制端）”，反转的结果是由对方即Product来维持关联关系。用单向关联更容易说明”维持关联关系“是什么意思：考虑用单向关系来实现这个映射关系的情况，即由Category关联到Product，考虑下面的代码：
Product p=new Product();
..setXXX
Category c=new Category();
..设置Category的属性
c.addProduct(p);//建立起了c和p的关联关系
session.save(c);
会执行三条SQL语句:两条插入语句，分别插入c和p，然后还有一条update语句建立起c和p的关联（更新p的外键）。上面，我们说由Category端控制关联，因此p.setCategory(c)这样一句话是没用的,它并不会导致在插入p的时候就设置p的外键以建立起两者的关联关系，从而节省一条update语句。同时我们还会看到，如果在数据库模式中将p的外键设置成非空，这些代码将不能执行，因为在插入p时，由于c和p的关联关系还未建立起来，因此p的外键为空。回到双向关联上来，为了更清楚地明白inverse在双向关联中到底起什么作用，我们分别将其值设为true和false,看看打印出的的SQL有何区别：
inverse=true时的打印结果：
Hibernate: insert into category (name, description) values (?, ?)
Hibernate: insert into product (name, description, category) values (?, ?, ?)
inverse=false时的打印结果：
Hibernate: insert into category (name, description) values (?, ?)
Hibernate: insert into product (name, description, category) values (?, ?, ?)
Hibernate: update product set category=? where id=?
为什么inverse=true时会比inverse=false时少执行一条SQL语句？这是由控制端的不同造成的。前者说"我要反转控制，由Product来控制关联"，因此在将p对象insert时，p已经设置了其category字段，从而建立了关联关系，而后者说"我不反转控制，由我自己来控制关联",因此在将p对象insert后，c为了维持两者的关联，还要去执行一次update，以更新p的外键，从而建立起两者的关联关系。
结论：对于一对多双向关系，始终在“一”那一方将其inverse设置成true,这样会提高性能。
二.cascade
级联。当关联的"一"方进行某种动作（更新，删除）时，"多"方即使没有显式地进行编码，它也会自动进行同样的动作。cascade的可选值有：
all : 所有情况下均进行关联操作。即是save-update + delete
none：所有情况下均不进行关联操作。这是默认值。
save-update:在执行save/update/saveOrUpdate时进行关联操作。
delete：在执行delete时进行关联操作。
all-delete-orphan:A:级联save-update B级联delete C:删除所有孤儿项（orphan孤儿）。先看看父子关系，例如在Customer和Order的模型中，这两者便是父子关系，当一个Customer的生命周期决定Order的生命周期，如果一个Customer不在了，其相关的Order继续存在是毫无业务意义的。删除所有孤儿项的意思即是，删除所有与父对象失去关联关系的子对象。
三.lazy
是否延迟加载。一般来说，应该延迟加载，即将lazy设为true。延迟加载的相关点很多，这在另外的学习笔记中总结。
四.unsaved-value
以上是"一"方的重要配置，再看看"多"方的一个重要配置:unsaved-value,就像上面Product.hbm.xml中的设置那样，这一项在id的配置中设置。这一设置是与级联一起工作的。关于这一点，robbin讲的很清楚：
当你显式的使用session.save()或者session.update()操作一个对象的时候，实际上是用不到unsaved-value 的。某些情况下(父子表关联保存)，当你在程序中并没有显式的使用save或者update一个持久对象，那么Hibernate需要判断被操作的对象究竟是一个已经持久化过的持久对象，是一个尚未被持久化过的内存临时对象。例如：
Session session = ...;
Transaction tx = ...;
Parent parent = (Parent) session.load(Parent.class, id);
Child child = new Child();
child.setParent(parent);
child.setName("sun");
parent.addChild(child);
s.update(parent);
s.flush();
tx.commit();
s.close();
在上例中，程序并没有显式的session.save(child); 那么Hibernate需要知道child究竟是一个临时对象，还是已经在数据库中有的持久对象。如果child是一个新创建的临时对象(本例中就是这种情况)，那么Hibernate应该自动产生session.save(child)这样的操作，如果child是已经在数据库中有的持久对象，那么 Hibernate应该自动产生session.update(child)这样的操作。因此我们需要暗示一下Hibernate，究竟 child对象应该对它自动save还是update。在上例中，显然我们应该暗示Hibernate对child自动save，而不是自动 update。那么Hibernate如何判断究竟对child是save还是update呢？它会取一下child的主键属性 child.getId() ，这里假设id是 java.lang.Integer类型的。如果取到的Id值和hbm映射文件中指定的unsave-value相等，那么Hibernate认为 child是新的内存临时对象，发送save，如果不相等，那么Hibernate认为child是已经持久过的对象，发送update。unsaved-value="null" (默认情况，适用于大多数对象类型主键 Integer/Long/String/...)
当Hibernate取一下child的Id，取出来的是null(在上例中肯定取出来的是null)，和unsaved-value设定值相等，发送save(child)
当Hibernate取一下child的id，取出来的不是null，那么和unsaved-value设定值不相等，发送update(child)
unsaved-value的可选配置有：
none，any，null
unsaved-value="none"和unsaved-value="any"主要用在主键属性不是通过Hibernate生成，而是程序自己setId()的时候。unsaved-value="none"和unsaved-value="any"究竟有什么含义了。如果你非要用assigned不可，那么继续解释一下：
unsaved-value="none" 的时候，由于不论主键属性为任何值，都不可能为none，因此Hibernate总是对child对象发送update(child)
unsaved-value="any" 的时候，由于不论主键属性为任何值，都肯定为any，因此Hibernate总是对child对象发送save(child)
大多数情况下，可以避免使用assigned，只有当你使用复合主键的时候不得不手工setId()，这时候需要你自己考虑究竟怎么设置unsaved-value了，根据你自己的需要来定。
关于为什么不要使主键带有义务意义，robbin的解释很清楚：还是以上面的例子打比方，如果我们将Category的某一个性质（比如产品序号或者名称）作为主键，如果后来由于业务需要，我们把这个性质改了，那将不可僻免地要去修改与这个对象相关联的所有数据的外键，而如果我们只要代理主键，这个问题就可完全僻免。