lazy概念：要用到的時候，再去加載，對於關聯的集合來說，只有當訪問到的時候，才去加載它所關聯的集合，比如一個user對應很多權限，只有當user.getRights()的時候，才發出select right的語句，在訪問到rights之前，rights是一個PersisitSet對於實體類來說，只有當它的屬性被訪問到時，才會真正加載這個實體類,在它的屬性沒有被訪問到之前，這個實體類是一個代理對象。
，可以取值：true/false/extra
<set name="name" lazy="true/false/extra" >
默認為true
默認為true情況下，當使用到了Set對象，才會把整個set全部查詢出來。
false情況下，不使用Lazy，查詢Lazy所屬的對象時，set就會被查詢上來。extra情況下，比較智能，根據查詢的內容，生成不同的SQL語句。效率會高一些。
例子：在我們前邊多對一的關系中（部門與員工）：
Department.hbm.xml：
[html] view plain copy
print?
通過這個可以關閉默認的懶加載
<many-to-one name="name" lazy="false/proxy/no-proxy">
默認為proxy
false:不使用Lazy。此關聯總是被預先抓取
proxy:使用懶加載
no-proxy：指定此屬性應該在實例變量第一次被訪問時應該延遲抓取（fetche lazily）
[html] view plain copy
print?
(You can't set lazy="proxy" to a collection, nor can you set lazy="true" to a single reference. Either will cause NH to throw a XmlSchemaException which is a little cryptic to beginners.)
比如說在college.hbm.xml裡面寫上
<set name="majors" inverse="true" lazy="false" cascade="delete">
加載學院時立刻加載學院的專業，那麼在查詢所有學院時，產生的sql語句如下：
Hibernate: select majors0_.college_id as college_2_3_0_, majors0_.major_id as major_id1_6_0_, majors0_.major_id as major_id1_6_1_, majors0_.college_id as college_2_6_1_, majors0_.major_name as major_na3_6_1_, majors0_.major_code as major_co4_6_1_ from studorm.tb_major majors0_ where majors0_.college_id=?
在查詢所有學院的時候，會立刻加載每個學院的專業，所以如非必要，不要加上
十分浪費資源
以下來自：http://www.cnblogs.com/wukenaihe/archive/2013/06/11/3131640.html
除了用在<set> 和 <one-to-one><many-to-one>標簽上，lazy還能用在
* <class>標簽上，可以取值：true/false ，在hibernate3以上版本，默認是true
* <property>標簽上，可以取值：true/false
在<class>標簽上，可以取值：true/false ，在hibernate3以上版本，默認是true
默認為true，可不寫，在執行查詢語句時不進行，比如session.load(id)時，不執行sql語句（session.get(id)不支持lazy），而是在具體獲取參數時，執行sql語句，比如obj.getName()。
<class>標簽上的lazy特性只對普通屬性起作用
<class>標簽上的lazy不會影響到單端關聯上的lazy特性
如果想對實體對象使用延遲加載，必須要在實體的映射配置文件中進行相應的配置
<class name="Person" table="PERSON" lazy="true">
1 tx = session.beginTransaction();
2 Person p=(Person) session.load(Person.class, "001");//(1)
3 System.out.println("0: "+p.getPersonId());//(2)
4 System.out.println("0: "+p.getName());//(3)
5 tx.commit();
6 session.close();
執行到(1)並沒有出現sql語句，並沒有從數據庫中抓取數據。這個時候查看內存對象p如下：
圖2.1 person對象load時的內存快照
觀察person對象，我們可發現是Person$$EnhancerBy..的類型的對象。這裡所返回的對象類型就是Person對象的代理對象，在hibernate中通過使用CGLB來先動態構造一個目標對象的代理類對象，並且在代理對象中包含目標對象的所有屬性和方法。所以，對於客戶端而言是否為代理類是無關緊要的，對他來說是透明的。這個對象中，僅僅設置了id屬性（即personId的值）,這是為了便於後面根據這個Id從數據庫中來獲取數據。
運行到(2)處，輸出為001，但是仍然沒有從數據庫裡面讀取數據。這個時候代理類的作用就體現出來了，客戶端覺得person類已經實現了（事實上並未創建）。但是，如果這個會後session關閉，再使用person對象就會出錯了。
調試運行到(3)處，要用到name屬性，但是這個值在數據庫中。所以hibernate從數據庫裡面抓取了數據，sql語句如下所示：
Hibernate:
select
person0_.PERSONID as PERSONID3_0_,
person0_.NAME as NAME3_0_
from
PERSON person0_
where
person0_.PERSONID=?
這時候，我們查看內存裡面的對象如下：
圖2.2 class延遲加載時內存對象
真正的Person對象放在CGLIB$CALLBACK_0對象中的target屬性裡。
這樣，通過一個中間代理對象，Hibernate實現了實體的延遲加載，只有當用戶真正發起獲得實體對象屬性的動作時，才真正會發起數據庫查詢操作。所以實體的延遲加載是用通過中間代理類完成的，所以只有session.load()方法才會利用實體延遲加載，因為只有session.load()方法才會返回實體類的代理類對象。
Hibernate默認的策略便是非延遲加載的，所以設置lazy=false
1 tx = session.beginTransaction();
2 Person p=(Person) session.load(Person.class, "001");//(1)
3 System.out.println("0: "+p.getPersonId());//(2)
4 System.out.println("0: "+p.getName());//(3)
5 tx.commit();
6 session.close();
調試運行到(1)處時，hibernate直接執行如下sql語句：
Hibernate:
select
person0_.PERSONID as PERSONID3_0_,
person0_.NAME as NAME3_0_
from
PERSON person0_
where
person0_.PERSONID=?
我們在查看內存快照如下：
這個時候就不是一個代理類了，而是Person對象本身了。裡面的屬性也已經全部普通屬性也全部被加載。這裡說普通屬性是因為addresses這個集合對象並沒有被加載，因為set自己本身也可以設置lazy屬性。所以，這裡也反映出class對象的lazy並不能控制關聯或集合的加載策略。
2.3 總結
Hibernate中<class lazy="">默認為true。如果，在load的時候只會返回一個代理類，並不會正在從數據庫中讀取數據。第一次用到時，會將所有普通屬性（set這種就不是）全部加載進來。如果第一次使用到時，session已經關閉將發生錯誤。
如果顯式是設置lazy=false，load的時候即會把所有普通屬性全部讀取進來。而且，返回的將是一個真正的該類型的對象(如Person)，而不是代理類。
在Hibernate3中，引入了一種新的特性——屬性的延遲加載，這個機制又為獲取高性能查詢提供了有力的工具。在大數據對象讀取時，如Person對象中有一個School字段，該字段是一個java.sql.Clob類型，包含了用戶的簡歷信息，當我們加載該對象時，我們不得不每一次都要加載這個字段，而不論我們是否真的需要它，而且這種大數據對象的讀取本身會帶來很大的性能開銷。
1、 <class lazy="false">
配置如下
1 tx = session.beginTransaction();
2 Person p=(Person) session.load(Person.class, "001");//(1)
3 System.out.println("");//(2)
4 System.out.println("0: "+p.getPersonId());//(3)
5 System.out.println("0: "+p.getName());//(4)
6 System.out.println("0: "+p.getSchool());//(5)
7 tx.commit();
1 <property name="name" type="java.lang.String">
2 <column name="NAME" />
3 </property>
4 <property name="school" type="java.lang.String" lazy="true">
5 <column name="SCHOOL"></column>
6 </property>
當運行到1的時候，全部加載了，執行語句如下：
Hibernate:
select
person0_.PERSONID as PERSONID3_0_,
person0_.NAME as NAME3_0_,
person0_.SCHOOL as SCHOOL3_0_
from
PERSON person0_
where
person0_.PERSONID=?
所有普通屬性都均已加載。
2、<class lazy="true">
School的lazy屬性自然還是true。當程序運行到（4）時，也同樣加載了全部屬性，執行了如下sql：
Hibernate:
select
person0_.PERSONID as PERSONID3_0_,
person0_.NAME as NAME3_0_,
person0_.SCHOOL as SCHOOL3_0_
from
PERSON person0_
where
person0_.PERSONID=?
結果就是無效，不管采用何種策略都是無效的，和我們想想的有較大出路。下面是一段來自hibernate官方文檔的話。
Lazy property loading requires buildtime bytecode instrumentation. If your persistent classes are not enhanced, Hibernate will ignore lazy property settings and return to immediate fetching.
應該是因為，我們並未用到編譯時字節碼增強技術的原因。如果只對部分property進行延遲加載的話，hibernate還提供了另外的方式，也是更為推薦的方式，即HQL或者條件查詢。
A different way of avoiding unnecessary column reads, at least for read-only transactions, is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a preferred solution.
