hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false ，在hibernate3以上版本，默认是true
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/no-proxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

=====================================================

1. <class>标签上:

hbm

group.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model">
    <class name="Group" table="group5" lazy="true" > //lazy，默认true，可不写
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native" />         
        </id>
        <property name="name" column="name" length="50" type="java.lang.String" />
       
    </class>

</hibernate-mapping>

测试用例：

public class LazyTest extends TestCase {

public void testLoad1(){
   Session session = null;
   Transaction ta = null;
   try{
    session = HibernateUtil.getSession();
    ta = session.beginTransaction();

    Group g2 = (Group) session.load(Group.class, 1); //还没发出sql，lazy起延迟作用,若lazy=false,则发出sql
//    Group g2 = (Group) session.get(Group.class, 1); //不支持lazy
    System.out.println("group.id=" + g2.getId()); //还没发出sql，
    System.out.println("group.name=" + g2.getName()); //发出sql
    ta.commit();
   }catch(Exception e){
    e.printStackTrace();
    if(ta != null){
     ta.rollback();
    }
   }finally{
    //关闭session， user变为detached离线对象
    HibernateUtil.closeSession(session);
   }
   //System.out.println("group.name=" + g2.getName()); //hibernate支持lazy策略只有在session打开状态下有效,所以此出Exception
}

}

<class>标签上的lazy特性只对普通属性起作用

<class>标签上的lazy不会影响到单端关联上的lazy特性

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

2.<set><list>标签上，可以取值：true/false/extra，默认是true

hbm.xml

Classes.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zd.model">
    <class name="Classes" table="classes" >
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="native" />
        </id>
        <property name="name" column="name" type="java.lang.String" />
       <set name="students" lazy="true"> //可不配lazy，因默认是true
            <key column="class_id" />
            <one-to-many class="com.zd.model.Student" />
        </set>
    </class>

</hibernate-mapping>

测试用例：

public void testLoad1(){
   Session session = null;
   Transaction ta = null;
   try{
    session = HibernateUtil.getSession();
    ta = session.beginTransaction();
    Classes c = (Classes) session.load(Classes.class, new Integer(2)); //没有sql
    System.out.println("Class.name=" + c.getName());//发出一条sql，但不查 set
    Set stuSet = c.getStudents();//没有发出查询sql，不是统计sql
    //System.out.println(stuSet.size());//发出查询sqlsql
    if(stuSet != null && !stuSet.isEmpty()){//发出查询sqlsql
     for(Iterator it = stuSet.iterator(); it.hasNext();){
      Student s = (Student) it.next();//若没有.size(),isEmpty(),就在这边发出sql
      System.out.println("student.name=" + s.getName());
     }
    }
    ta.commit();
   }catch(Exception e){
    e.printStackTrace();
    if(ta != null){
     ta.rollback();
    }
   }finally{
    //关闭session， user变为detached离线对象
    HibernateUtil.closeSession(session);
   }
  
}

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Class.name=Java Class
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student students0_ where students0_.class_id=?
2
student.name=z3
student.name=l4

若<set name="students" lazy="false"> //不延迟加载, 马上加载

则在

System.out.println("Class.name=" + c.getName());// 就发出2条查询语句了。

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student students0_ where students0_.class_id=?
Class.name=Java Class
student.name=l4
student.name=z3

若<set name="students" lazy="extra"> //和true差不多，只是在写set.size()时，发出selcet count的sql语句，比true好一些。

测试用例：

public void testLoad1(){
   Session session = null;
   Transaction ta = null;
   try{
    session = HibernateUtil.getSession();
    ta = session.beginTransaction();
    Classes c = (Classes) session.load(Classes.class, new Integer(2));
    System.out.println("Class.name=" + c.getName());
    Set stuSet = c.getStudents();
   System.out.println(stuSet.size());
    if(stuSet != null && !stuSet.isEmpty()){
     for(Iterator it = stuSet.iterator(); it.hasNext();){
      Student s = (Student) it.next();
      System.out.println("student.name=" + s.getName());
     }
    }
    ta.commit();
   }catch(Exception e){
    e.printStackTrace();
    if(ta != null){
     ta.rollback();
    }
   }finally{
    //关闭session， user变为detached离线对象
    HibernateUtil.closeSession(session);
   }
  
}

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from classes classes0_ where classes0_.id=?
Class.name=Java Class
Hibernate: select count(id) from student where class_id =?
2
Hibernate: select students0_.class_id as class3_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_, students0_.class_id as class3_1_0_ from student students0_ where students0_.class_id=?
student.name=z3
student.name=l4

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

3.<one-to-one><many-to-one>单端关联上，可以取值：false/proxy/no-proxy，默认是proxy(代理），延迟加载作用

hbm.xml

User.hbm.xml 多的一端

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.model">
    <class name="User" table="user1" >
        <id name="id" column="user_id" type="java.lang.Integer">
            <generator class="native" />
        </id>
        <property name="name" length="50" type="java.lang.String" />
        <many-to-one name="group" column="group_id" lazy="proxy"></many-to-one> //可不写，默认是proxy
    </class>

</hibernate-mapping>

测试用例：

public void testGet1(){
   Session session = null;
   Transaction ta = null;
   User user = null;
   try{
    session = HibernateUtil.getSession();
    ta = session.beginTransaction();
    user = (User)session.load(User.class, new Integer(3)); //无sql
    System.out.println("user.name=" + user.getName()); //有一条sql
    Group group = user.getGroup();//无sql
    System.out.println("group.name=" + group.getName());//有一条sql
    ta.commit();
   }catch(Exception e){
    e.printStackTrace();
    ta.rollback();
   }finally{
    //关闭session， user变为detached离线对象
    HibernateUtil.closeSession(session);
   }
  
}

若<many-to-one name="group" column="group_id" lazy="false"></many-to-one>

不延迟加载，立即加载，

System.out.println("user.name=" + user.getName()); //发出2条sql语句

==========================================

hibernate 中的 lazy="proxy" 和 lazy="no-proxy" 到底是什么意思?

举个例子吧：
Child <- many-to-one ->Parent

class Child {
private Parent parent;

public Parent getParent (){
return this.parent;//访问了实例变量
}

}

class Parent {
private String name;

public String getName(){
return this.name;//访问了实例变量
}

public void f(){
System.out.println("invokeing f()");//没有访问实例变量
}
}

如果 many-to-one 的lazy设为proxy,当child.getParent().getName()或child.getParent().f()时，parent都 会被抓取，若设为no-proxy,调用child.getParent().f()时，parent是不会被抓取的，同时这种方式需要编译时字节码增强，否则和proxy没区别。 (注：测试发现真和proxy一样，不能理解 编译时字节码增强，要再哪修改，或是什么条件？）

如 果设置了 lazy="proxy"，就   ，当通过 child 来调用其关联的 parent， 如果调用 parent 类中定义的任何方法,都会抓取 parent (所谓的抓取是不是就是从数据库查询,执行一次 select ?)
如果设置了 lazy="no-proxy" ,只有调用 parent 类中牵涉到类变量的方法,才会抓取 parent,否则,就像调用 f(), 不会抓取 parent  

."编译时字节码增强" 是什么意思?
"字节码增强"分编译期和运行期2种，编译期是修改java类编译后的class字节码文件，在上面附加“增强”操作。（不明白why？）

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

    所以到处找资料, 但是无论从一些讲 Hibernate 书籍,还是他人 Blog 中都没有找到详细

    介绍 Hibernate 文档中所说的原汁原味的抓取策略, 综合懒加载等等特性混在了一起, 所

    以在这自己在借鉴了他人的基础上研究了下原汁原味的 Hibernate 四种"抓取策略";

• 连 接抓取（Join fetching） - Hibernate通过 在SELECT语句使用OUTER JOIN
（外连接）来 获得对象的关联实例或者关联集合.

  ---

• 查 询抓取（Select fetching） - 另外发送一条 SELECT 语句抓取当前对象的关联实
  体或集合。除非你显式的指定lazy="false"禁止 延迟抓取（lazy fetching），否
  则只有当你真正访问关联关系的时候，才会执行第二条select语句.

  ---

• 子查询抓取（Subselect fetching） - 另外发送一条SELECT 语句抓取在前面查询到
  （或者抓取到）的所有实体对象的关联集合。除非你显式的指定lazy="false" 禁止延迟
  抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条
  select 语句

  ---

• 批量抓取（Batch fetching） - 对查询抓取的优化方案， 通过指定一个主键或外键
  列表，Hibernate使用单条SELECT语句获 取一批对象实例或集合

    这是文档中的四种抓取策略, 我用 Customer 与 Order 的一个双向一对多例子来使用四种

    抓取策略看看他们的不同之处;

    Customer :

1. public class Customer { 
2. private long id; 
3. private String name; 
4. private Set<Order> orders; 
5. // getter/setter 略
6. } 

    Order :

1. public class Order { 
2. private long id; 
3. private String name; 
4. private Customer customer; 
5. // getter/setter略
6. } 

Order 的映射文件是不变的, 放在这 :

1. <hibernate-mapping package="com.purking.strategys.endUpOne">
2. <class name="Order" table="Order_Table">
3. <id name="id">
4. <generator class="native" />
5. </id>
6. <property name="name" length="20" column="Order_Name" />
7. <many-to-one name="customer"
8. class="Customer"
9. lazy="proxy"
10. fetch="select"
11. column="Cus_ID"
12. cascade="save-update" />
13. </class>
14. </hibernate-mapping>

连 接抓取（Join fetching）

    连接抓取, 使用连接抓取可以将原本需要查询两次(或多次)表的多次查询 整合到只需

要一次查询即可完成, 举个例子, 我们在初始化一个含有一对多关系的 Customer 与

Order 的时候, 会先查询 Customer 表,找到需要的 Customer , 然后再根据

Customer.id 到 Order 表中查询将Order 集合初始化, 那么在此完成初始化则需要

发送至少两条 SQL 语句, 而如果使用 join 查询的话, 其会根据需要查询的

Customer.id, 将 Customer 表与 Order 表连接起来进行查询,仅仅一条 SQL 语

句就可以将需要的数据全部查询回来;

使用连接抓取的配置文件 :

1. <hibernate-mapping package="com.purking.strategys.endUpOne">
2. <class name="Customer" table="Customer_Table" lazy="true">
3. <id name="id">
4. <generator class="native" />
5. </id>
6. <property name="name" length="20" column="Cus_Name" />
7. <set name="orders"
8. inverse="true"
9. fetch="join"  //---- Here 
10. <!-- 这里关闭懒加载是为了试验明显 -->
11. lazy="false">
12. <key column="Cus_ID" />
13. <one-to-many class="Order" />
14. </set>
15. </class>
16. </hibernate-mapping>

我们使用如此查询语句 :

1. Customer c1 = (Customer)session.get(Customer.class, 11l); 
2. c1.getOrders().size(); 

Hibernate 发出的 SQL 语句为 :

1. select 
2.     customer0_.id as id0_1_, 
3.     customer0_.Cus_Name as Cus2_0_1_, 
4.     orders1_.Cus_ID as Cus3_3_, 
5.     orders1_.id as id3_, 
6.     orders1_.id as id1_0_, 
7.     orders1_.Order_Name as Order2_1_0_, 
8.     orders1_.Cus_ID as Cus3_1_0_  
9. from 
10.     Customer_Table customer0_  
11. left outer join 
12.     Order_Table orders1_  
13.         on customer0_.id=orders1_.Cus_ID  
14. where 
15. customer0_.id=? 

在此, Hibernate 使用了 left outer join 连接两个表以一条 SQL 语句将 Order 集合

给初始化了;

查询抓取（Select fetching）

    查询抓取, 这种策略是在集合抓取的时候的默认策略, 即如果集合需要初始化, 那么

会重新发出一条 SQL 语句进行查询; 这是集合默认的抓取策略, 也就是我们常会出现

N+1次查询的查询策略;

配 置文件 :

1. <hibernate-mapping package="com.purking.strategys.endUpOne">
2. <class name="Customer" table="Customer_Table" lazy="true">
3. <id name="id">
4. <generator class="native" />
5. </id>
6. <property name="name" length="20" column="Cus_Name" />
7. <set name="orders"
8. inverse="true"
9. fetch="select">
10. <key column="Cus_ID" />
11. <one-to-many class="Order" />
12. </set>
13. </class>
14. </hibernate-mapping>

查询语句不变, 看看 Hibernate 发出的 SQL 语句:

1. Hibernate:  
2.     select 
3.         customer0_.id as id0_0_, 
4.         customer0_.Cus_Name as Cus2_0_0_  
5.     from 
6.         Customer_Table customer0_  
7.     where 
8. customer0_.id=? 
9. Hibernate:  
10.     select 
11.         orders0_.Cus_ID as Cus3_1_, 
12.         orders0_.id as id1_, 
13.         orders0_.id as id1_0_, 
14.         orders0_.Order_Name as Order2_1_0_, 
15.         orders0_.Cus_ID as Cus3_1_0_  
16.     from 
17.         Order_Table orders0_  
18.     where 
19. orders0_.Cus_ID=? 

这就是, 重新发出一条 SQL 语句, 初始化了 Orders 集合;

子查询抓取（Subselect fetching）

    子查询抓取, 另外发送一条SELECT 语句抓取在前面查询到（或者抓取到）的所有实

体对象的关联集合. 这个理解起来有点糊涂, 举个例子 : 如果你使用 Query 查询出了

4 个 Customer 实体, 由于开启了懒加载,那么他们的 Orders 都没有被初始化, 那么我

现在手动初始化一个Customer 的 Orders ,此时由于我选的是 Subselect fetching

策略,所以 Hibernate 会将前面查询到的实体对象(4 个 Customer)的关联集合(在

<set name="orders" fetch="subselect" /> )使用一条 Select 语句一次性抓取

回来, 这样减少了与数据库的交互次数, 一次将每个对象的集合都给初始化了;

[他 是如何这么智能的呢? 原来,他是将上一次查询的 SQL 语句作为这一次查询的 SQL

语句的 where 子查询, 所以上次查询到几个对象,那么这次就初始化几个对象的集

合----- 正因为如此, 所以 subselect 只在 <set> 集合中出现 ];

配置文件:

1. <hibernate-mapping package="com.purking.strategys.endUpOne">
2. <class name="Customer" table="Customer_Table" lazy="true">
3. <id name="id">
4. <generator class="native" />
5. </id>
6. <property name="name" length="20" column="Cus_Name" />
7. <set name="orders"
8. inverse="true"
9. fetch="subselect"
10. lazy="true">
11. <key column="Cus_ID" />
12. <one-to-many class="Order" />
13. </set>
14. </class>
15. </hibernate-mapping>

测试的语句有变化 :

1. List results = session 
2. .createQuery("From Customer c where c.id in (11,14,17,20)") 
3. .list(); 
4. // 这里的四个 id 是我数据库中已经准备好的数据
5. Customer c0 = (Customer)results.get(0); 
6. c0.getOrders().size(); 

这个时候再来看看 Hibernate 发出了什么样的 SQL 语句 :

1. Hibernate:  
2.     select 
3.         customer0_.id as id0_, 
4.         customer0_.Cus_Name as Cus2_0_  
5.     from 
6.         Customer_Table customer0_  
7.     where 
8.         customer0_.id in ( 
9.             11 , 14 , 17 , 20 
10.         ) 
11. Hibernate:  
12.     select 
13.         orders0_.Cus_ID as Cus3_1_, 
14.         orders0_.id as id1_, 
15.         orders0_.id as id1_0_, 
16.         orders0_.Order_Name as Order2_1_0_, 
17.         orders0_.Cus_ID as Cus3_1_0_  
18.     from 
19.         Order_Table orders0_  
20.     where 
21.         orders0_.Cus_ID in ( 
22.             select 
23.                 customer0_.id  
24.             from 
25.                 Customer_Table customer0_  
26.             where 
27.                 customer0_.id in ( 
28.                     11 , 14 , 17 , 20 
29.                 ) 
30.         ) 

是 不是发出的 SQL 语句形式与这个抓取策略的名字一样? Hibernate 的命名很清晰的;

批量抓取（Batch fetching）

批量抓取:"对查询抓取的 优化方案,通过指定一个主键或外键列表，Hibernate使用

单条SELECT语句获取一批对象实例或集合", 也就是说其本质与 select fetching 是

一样的,只不过将一次一条的 select 策略改为一次 N 条的批量 select 查询; 举个例

子 : 还是借用 Subselect fetching 的例子,我查询出了 4 个 Customer 实体,

Orders 开启了懒加载, 所以我现在来手动初始化一个 Customer 的 orders 属性,

这种策略本质上就是 select fetching,所以如此设置 :

<set name="orders" fetch="select" batch-size="3" /> 那么此时我初始化

一个 Customer 的 orders 集合的时候, Hibernate 还是发出了一条 SQL 语句,

不过这条 SQL 与是通过指定了 Order 表中的 Customer_ID 外键列表(2个), 这个

时候 Hibernate 会以一条 SQL 语句初始化 batch-size 指定的数量的 orders 集合;

[他是如何做到的呢? 通过一个主键或外键 列表 做到的, 他将 4 个 Customer 根据

batch-size 分成了两组, 一组有三个 Customer id 值的列表,第二组只有一个,

在初始化 orders 集合的时候就是根据这两个列表来初始化的]

配置文件 :

1. <hibernate-mapping package="com.purking.strategys.endUpOne"> 
2.     <class name="Customer" table="Customer_Table" lazy="true"> 
3.         <id name="id"> 
4.             <generator class="native" /> 
5.         </id> 
6.         <property name="name" length="20" column="Cus_Name" /> 
7.         <set name="orders"
8.              inverse="true"
9.              fetch="select"
10.              lazy="true"
11.              batch-size="3"> 
12.             <key column="Cus_ID" /> 
13.             <one-to-many class="Order" /> 
14.         </set> 
15.     </class> 
16. </hibernate-mapping> 

在此,我关闭了集合默认的懒加载, 更有利于试验结果测试代码不变,

再来看看 Hibernate 发出的 SQL 语句 :

1. Hibernate:  
2.     select 
3.         customer0_.id as id0_, 
4.         customer0_.Cus_Name as Cus2_0_  
5.     from 
6.         Customer_Table customer0_  
7.     where 
8.         customer0_.id in ( 
9.             11 , 14 , 17 , 20 
10.         ) 
11. Hibernate:  
12.     select 
13.         orders0_.Cus_ID as Cus3_1_, 
14.         orders0_.id as id1_, 
15.         orders0_.id as id1_0_, 
16.         orders0_.Order_Name as Order2_1_0_, 
17.         orders0_.Cus_ID as Cus3_1_0_  
18.     from 
19.         Order_Table orders0_  
20.     where 
21.         orders0_.Cus_ID in ( 
22.             ?, ?, ? 
23.         ) 
24. Hibernate:  
25.     select 
26.         orders0_.Cus_ID as Cus3_1_, 
27.         orders0_.id as id1_, 
28.         orders0_.id as id1_0_, 
29.         orders0_.Order_Name as Order2_1_0_, 
30.         orders0_.Cus_ID as Cus3_1_0_  
31.     from 
32.         Order_Table orders0_  
33.     where 
34. orders0_.Cus_ID=? 

原本需要四次 Select 的查询, 由于 Batch-size=3 只用了两次

就完成了;

总结:

    好了, 这里的四种抓取策略说明完了, 来全局看一下, 通过例子可以看出, 这四种抓取

策略并不是所有的情况都合适的, 例如, 如果我需要初始化的是一个单独的实体, 那

么 subselect 对其就没有效果,因为其本身就只需要查询一个对象, 所以 :

1. Join fetching , Select fetching 与 Batch-size 可以为单个实体的抓取进
   行性能优化;
2. Join fetching , Select fetching ,Subselect fetching , Batch fetching
   都 可以为集合的抓取进行性能优化;

注: 这里对于单个实体可以使用 Batch-size 可能会有点疑惑, 其实在 <class > 上是

具有 Batch-size 抓取策略的; 试想, 使用一个如果是一对一关系呢? 例如 Customer

与 IdCard, 利用 HQL 查询出 4 个 Customer , 我们想一次性初始化 4 个 Customer

的 IdCard 怎么办, 设置 <class name="IdCard" batch-size="4" > , 可能我们

想设置的地方是 <one-to-one batch-size> 但是这里没有提供这个属性, 可能是因为

如果设置了不好理解吧..

在上例中，程序并没有显式的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)

例如下面的情况：

child已经在数据库中有了，是一个持久化的对象，不是新创建的，因此我们希望Hibernate发送update(child)，在该例 中，Hibernate取一下child.getId()，和unsave-value指定的null比对一下，发现不相等，那么发送 update(child)。

BTW: parent对象不需要操心，因为程序显式的对parent有load操作和update的操作，不需要Hibernate自己来判断究竟是save还是 update了。我们要注意的只是child对象的操作。另外unsaved-value是定义在Child类的主键属性中的。

如果主键属性不是对象型，而是基本类型，如int/long/double/...，那么你需要指定一个数值型的unsaved-value，例如：

在此提醒大家，很多人以为对主键属性定义为int/long，比定义为Integer/Long运行效率来得高，认为基本类型不需要进行对象的封装 和解构操作，因此喜欢把主键定义为int/long的。但实际上，Hibernate内部总是把主键转换为对象型进行操作的，就算你定义为int /long型的，Hibernate内部也要进行一次对象构造操作，返回给你的时候，还要进行解构操作，效率可能反而低也说不定。因此大家一定要扭转一个 观点，在Hibernate中，主键属性定义为基本类型，并不能够比定义为对象型效率来的高，而且也多了很多麻烦，因此建议大家使用对象型的 Integer/Long定义主键。

unsaved-value="none"和
unsaved-value="any"

主主要用在主键属性不是通过Hibernate生成，而是程序自己setId()的时候。

在这里多说一句，强烈建议使用Hibernate的id generator，或者你可以自己扩展Hibernate的id generator，特别注意不要使用有实际含义的字段当做主键来用！例如用户类User，很多人喜欢用用户登陆名称做为主键，这是一个很不好的习惯，当 用户类和其他实体类有关联关系的时候，万一你需要修改用户登陆名称，一改就需要改好几张表中的数据。偶合性太高，而如果你使用无业务意义的id generator，那么修改用户名称，就只修改user表就行了。

由这个问题引申出来，如果你严格按照这个原则来设计数据库，那么你基本上是用不到手工来setId()的，你用Hibernate的id generator就OK了。因此你也不需要了解当

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了，根据你自己的需要来定。

BTW: Gavin King强烈不建议使用composite-id，强烈建议使用UserType。

因此，如果你在系统设计的时候，遵循如下原则：

1、使用Hibernate的id generator来生成无业务意义的主键，不使用有业务含义的字段做主键，不使用assigned。

2、使用对象类型(String/Integer/Long/...)来做主键，而不使用基础类型(int/long/...)做主键

3、不使用composite-id来处理复合主键的情况，而使用UserType来处理该种情况。

那么你永远用的是unsaved-value="null" ，不可能用到any/none/..了。