延遲加載
延遲加載機制是爲了避免一些無謂的性能開銷而提出來的,所謂延遲加載就是當在真正需要數據的時候,才真正執行數據加載操作。在Hibernate中提供了對實體對象的延遲加載以及對集合的延遲加載,另外在Hibernate3中還提供了對屬性的延遲加載。下面我們就分別介紹這些種類的延遲加載的細節
Hibernate中默認採用延遲加載的情況主要有以下幾種。
1)當調用Session上的load()方法加載一個實體時,會採用延遲加載
2)當Session記載某個實體時,會對這個實體中的集合屬性值採用延遲加載
3)當Session加載某個實體時,會對這個實體多單端關聯(one-to-one,many-to-one)的另一個實體對象採用延遲加載
下面我們就分別介紹這些種類的延遲加載的細節。
A、實體對象的延遲加載:
如果想對實體對象使用延遲加載,必須要在實體的映射配置文件中進行相應的配置,如下所示:
- <span style="font-size: large;"><hibernate-mapping>
- <class name=”com.neusoft.entity.User” table=”user” lazy=”true”>
- ……
- </class>
- </hibernate-mapping>
- </span>
通過將class的lazy屬性設置爲true,來開啓實體的延遲加載特性。如果我們運行下面的代碼:
- <span style="font-size: large;">User user=(User)session.load(User.class,”1”);(1)
- System.out.println(user.getName());(2) </span>
當運行到(1)處時,Hibernate並沒有發起對數據的查詢,如果我們此時通過一些調試工具(比如JBuilder2005的Debug工具),觀察此時user對象的內存快照,我們會驚奇的發現,此時返回的可能是User$EnhancerByCGLIB$$bede8986類型的對象,而且其屬性爲null,這是怎麼回事?還記得前面我曾講過session.load()方法,會返回實體對象的代理類對象,這裏所返回的對象類型就是User對象的代理類對象。在Hibernate中通過使用CGLIB,來實現動態構造一個目標對象的代理類對象,並且在代理類對象中包含目標對象的所有屬性和方法,而且所有屬性均被賦值爲null。通過調試器顯示的內存快照,我們可以看出此時真正的User對象,是包含在代理對象的CGLIB$CALBACK_0.target屬性中,當代碼運行到(2)處時,此時調用user.getName()方法,這時通過CGLIB賦予的回調機制,實際上調用CGLIB$CALBACK_0.getName()方法,當調用該方法時,Hibernate會首先檢查CGLIB$CALBACK_0.target屬性是否爲null,如果不爲空,則調用目標對象的getName方法,如果爲空,則會發起數據庫查詢,生成類似這樣的SQL語句:select * from user where id=’1’;來查詢數據,並構造目標對象,並且將它賦值到CGLIB$CALBACK_0.target屬性中。
這樣,通過一箇中間代理對象,Hibernate實現了實體的延遲加載,只有當用戶真正發起獲得實體對象屬性的動作時,才真正會發起數據庫查詢操作。所以實體的延遲加載是用通過中間代理類完成的,所以只有session.load()方法纔會利用實體延遲加載,因爲只有session.load()方法纔會返回實體類的代理類對象。
B、集合類型的延遲加載:
在Hibernate的延遲加載機制中,針對集合類型的應用,意義是最爲重大的,因爲這有可能使性能得到大幅度的提高,爲此Hibernate進行了大量的努力,其中包括對JDK Collection的獨立實現,我們在一對多關聯中,定義的用來容納關聯對象的Set集合,並不是java.util.Set類型或其子類型,而是net.sf.hibernate.collection.Set類型,通過使用自定義集合類的實現,Hibernate實現了集合類型的延遲加載。爲了對集合類型使用延遲加載,我們必須如下配置我們的實體類的關於關聯的部分:
- <span style="font-size: large;"><hibernate-mapping>
- <class name=”com.neusoft.entity.User” table=”user”>
- …..
- <set name=”addresses” table=”address” lazy=”true” inverse=”true”>
- <key column=”user_id”/>
- <one-to-many class=”com.neusoft.entity.Arrderss”/>
- </set>
- </class>
- </hibernate-mapping>
- </span>
通過將<set>元素的lazy屬性設置爲true來開啓集合類型的延遲加載特性。我們看下面的代碼:
- <span style="font-size: large;">User user=(User)session.load(User.class,”1”);
- Collection addset=user.getAddresses(); (1)
- Iterator it=addset.iterator(); (2)
- while(it.hasNext()){
- Address address=(Address)it.next();
- System.out.println(address.getAddress());
- }
- </span>
當程序執行到(1)處時,這時並不會發起對關聯數據的查詢來加載關聯數據,只有運行到(2)處時,真正的數據讀取操作纔會開始,這時Hibernate會根據緩存中符合條件的數據索引,來查找符合條件的實體對象。
這裏我們引入了一個全新的概念——數據索引,下面我們首先將接一下什麼是數據索引。在Hibernate中對集合類型進行緩存時,是分兩部分進行緩存的,首先緩存集合中所有實體的id列表,然後緩存實體對象,這些實體對象的id列表,就是所謂的數據索引。當查找數據索引時,如果沒有找到對應的數據索引,這時就會一條select SQL的執行,獲得符合條件的數據,並構造實體對象集合和數據索引,然後返回實體對象的集合,並且將實體對象和數據索引納入Hibernate的緩存之中。另一方面,如果找到對應的數據索引,則從數據索引中取出id列表,然後根據id在緩存中查找對應的實體,如果找到就從緩存中返回,如果沒有找到,在發起select SQL查詢。在這裏我們看出了另外一個問題,這個問題可能會對性能產生影響,這就是集合類型的緩存策略。如果我們如下配置集合類型:
- <span style="font-size: large;"><hibernate-mapping>
- <class name=”com.neusoft.entity.User” table=”user”>
- …..
- <set name=”addresses” table=”address” lazy=”true” inverse=”true”>
- <cache usage=”read-only”/>
- <key column=”user_id”/>
- <one-to-many class=”com.neusoft.entity.Arrderss”/>
- </set>
- </class>
- </hibernate-mapping>
- </span>
這裏我們應用了<cache usage=”read-only”/>配置,如果採用這種策略來配置集合類型,Hibernate將只會對數據索引進行緩存,而不會對集合中的實體對象進行緩存。如上配置我們運行下面的代碼:
- <span style="font-size: large;">User user=(User)session.load(User.class,”1”);
- Collection addset=user.getAddresses();
- Iterator it=addset.iterator();
- while(it.hasNext()){
- Address address=(Address)it.next();
- System.out.println(address.getAddress());
- }
- System.out.println(“Second query……”);
- User user2=(User)session.load(User.class,”1”);
- Collection it2=user2.getAddresses();
- while(it2.hasNext()){
- Address address2=(Address)it2.next();
- System.out.println(address2.getAddress());
- }
- </span>
- <span style="font-size: large;"><hibernate-mapping>
- <class name=”com.neusoft.entity.User” table=”user”>
- …..
- <set name=”addresses” table=”address” lazy=”true” inverse=”true”>
- <cache usage=”read-write”/>
- <key column=”user_id”/>
- <one-to-many class=”com.neusoft.entity.Arrderss”/>
- </set>
- </class>
- </hibernate-mappin</span>
此時Hibernate會對集合類型中的實體也進行緩存,如果根據這個配置再次運行上面的代碼,將會得到類似如下的輸出:
Select * from user where id=’1’;
Select * from address where user_id=’1’;
Tianjin
Dalian
Second query……
Tianjin
Dalian
這時將不會再有根據數據索引進行查詢的SQL語句,因爲此時可以直接從緩存中獲得集合類型中存放的實體對象。
C、屬性延遲加載:
在Hibernate3中,引入了一種新的特性——屬性的延遲加載,這個機制又爲獲取高性能查詢提供了有力的工具。在前面我們講大數據對象讀取時,在User對象中有一個resume字段,該字段是一個java.sql.Clob類型,包含了用戶的簡歷信息,當我們加載該對象時,我們不得不每一次都要加載這個字段,而不論我們是否真的需要它,而且這種大數據對象的讀取本身會帶來很大的性能開銷。在Hibernate2中,我們只有通過我們前面講過的面性能的粒度細分,來分解User類,來解決這個問題(請參照那一節的論述),但是在Hibernate3中,我們可以通過屬性延遲加載機制,來使我們獲得只有當我們真正需要操作這個字段時,纔去讀取這個字段數據的能力,爲此我們必須如下配置我們的實體類:
- <span style="font-size: large;"><hibernate-mapping>
- <class name=”com.neusoft.entity.User” table=”user”>
- ……
- <property name=”resume” type=”java.sql.Clob” column=”resume” lazy=”true”/>
- </class>
- </hibernate-mapping></span><span style="white-space: normal;"><span style="font-size: large;">
- </span></span>
通過對<property>元素的lazy屬性設置true來開啓屬性的延遲加載,在Hibernate3中爲了實現屬性的延遲加載,使用了類增強器來對實體類的Class文件進行強化處理,通過增強器的增強,將CGLIB的回調機制邏輯,加入實體類,這裏我們可以看出屬性的延遲加載,還是通過CGLIB來實現的。CGLIB是Apache的一個開源工程,這個類庫可以操縱java類的字節碼,根據字節碼來動態構造符合要求的類對象。根據上面的配置我們運行下面的代碼:
- <span style="font-size: large;">String sql=”from User user where user.name=’zx’ ”;
- Query query=session.createQuery(sql); (1)
- List list=query.list();
- for(int i=0;i<list.size();i++){
- User user=(User)list.get(i);
- System.out.println(user.getName());
- System.out.println(user.getResume()); (2)
- }
- </span>
Select id,age,name from user where name=’zx’;
這時Hibernate會檢索User實體中所有非延遲加載屬性對應的字段數據,當執行到(2)處時,會生成類似如下的SQL語句:
Select resume from user where id=’1’;
這時會發起對resume字段數據真正的讀取操作。
關閉延遲加載
延遲加載確實會給程序的查詢小驢帶來好處,但有時明確知道數據需要立即加載的,如果Hibernate先默認使用延遲加載而後又必須去數據庫加載,反而會降低效率。所以根據應用程序的實際情況來靈活控制是否使用延遲加載。在Hibenate中只需要修改相應的配置來啓用或關閉加載功能
1)在加載單個實體時,如果不需要延遲加載,就可以使用Session的get()方法
2)當Session加載某個實體時,不需要對這個實體中的集合屬性值延遲加載,而是要立即加載。這時可以在映射文件的配置元素(<set>、<bag>、<list>....)添加屬性lazy=false.
3)當Session加載某個實體時,不要要對這個實體多單端關聯(被關聯的是單端)的另一個實體對象延遲加載,就可以在映射文件中針對這個單端關聯的配置元素(<one-to-one>、<many-to-one>)添加屬性lazy=false