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的某一个性质（比如产品序号或者名称）作为主键，如果后来由于业务需要，我们把这个性质改了，那将不可僻免地要去修改与这个对象相关联的所有数据的外键，而如果我们只要代理主键，这个问题就可完全僻免。