hibernate的查詢緩存配置

㈠ Hibernate緩存如何實現

事務提交後，一級緩存中的數據會被更新到資料庫，如果二級緩存設置為讀寫，那麼這份數據會同時更新到二級緩存
緩存是介於應用程序和物理數據源之間，其作用是為了降低應用程序對物理數據源訪問的頻次，從而提高了應用的運行性能。緩存內的數據是對物理數據源中的數據的復制，應用程序在運行時從緩存讀寫數據，在特定的時刻或事件會同步緩存和物理數據源的數據。
緩存的介質一般是內存，所以讀寫速度很快。但如果緩存中存放的數據量非常大時，也會用硬碟作為緩存介質。緩存的實現不僅僅要考慮存儲的介質，還要考慮到管理緩存的並發訪問和緩存數據的生命周期。

Hibernate的緩存包括Session的緩存和SessionFactory的緩存，其中SessionFactory的緩存又可以分為兩類：內置緩存和外置緩存。Session的緩存是內置的，不能被卸載，也被稱為Hibernate的第一級緩存。SessionFactory的內置緩存和Session的緩存在實現方式上比較相似，前者是SessionFactory對象的一些集合屬性包含的數據，後者是指Session的一些集合屬性包含的數據。SessionFactory的內置緩存中存放了映射元數據和預定義sql語句，映射元數據是映射文件中數據的拷貝，而預定義SQL語句是在Hibernate初始化階段根據映射元數據推導出來，SessionFactory的內置緩存是只讀的，應用程序不能修改緩存中的映射元數據和預定義SQL語句，因此SessionFactory不需要進行內置緩存與映射文件的同步。SessionFactory的外置緩存是一個可配置的插件。在默認情況下，SessionFactory不會啟用這個插件。外置緩存的數據是資料庫數據的拷貝，外置緩存的介質可以是內存或者硬碟。SessionFactory的外置緩存也被稱為Hibernate的第二級緩存。

Hibernate的這兩級緩存都位於持久化層，存放的都是資料庫數據的拷貝，那麼它們之間的區別是什麼呢？為了理解二者的區別，需要深入理解持久化層的緩存的兩個特性：緩存的范圍和緩存的並發訪問策略。

持久化層的緩存的范圍

緩存的范圍決定了緩存的生命周期以及可以被誰訪問。緩存的范圍分為三類。

1 事務范圍：緩存只能被當前事務訪問。緩存的生命周期依賴於事務的生命周期，當事務結束時，緩存也就結束生命周期。在此范圍下，緩存的介質是內存。事務可以是資料庫事務或者應用事務，每個事務都有獨自的緩存，緩存內的數據通常採用相互關聯的的對象形式。

2 進程范圍：緩存被進程內的所有事務共享。這些事務有可能是並發訪問緩存，因此必須對緩存採取必要的事務隔離機制。緩存的生命周期依賴於進程的生命周期，進程結束時，緩存也就結束了生命周期。進程范圍的緩存可能會存放大量的數據，所以存放的介質可以是內存或硬碟。緩存內的數據既可以是相互關聯的對象形式也可以是對象的鬆散數據形式。鬆散的對象數據形式有點類似於對象的序列化數據，但是對象分解為鬆散的演算法比對象序列化的演算法要求更快。

3 集群范圍：在集群環境中，緩存被一個機器或者多個機器的進程共享。緩存中的數據被復制到集群環境中的每個進程節點，進程間通過遠程通信來保證緩存中的數據的一致性，緩存中的數據通常採用對象的鬆散數據形式。

對大多數應用來說，應該慎重地考慮是否需要使用集群范圍的緩存，因為訪問的速度不一定會比直接訪問資料庫數據的速度快多少。

持久化層可以提供多種范圍的緩存。如果在事務范圍的緩存中沒有查到相應的數據，還可以到進程范圍或集群范圍的緩存內查詢，如果還是沒有查到，那麼只有到資料庫中查詢。事務范圍的緩存是持久化層的第一級緩存，通常它是必需的；進程范圍或集群范圍的緩存是持久化層的第二級緩存，通常是可選的。

持久化層的緩存的並發訪問策略

當多個並發的事務同時訪問持久化層的緩存的相同數據時，會引起並發問題，必須採用必要的事務隔離措施。

在進程范圍或集群范圍的緩存，即第二級緩存，會出現並發問題。因此可以設定以下四種類型的並發訪問策略，每一種策略對應一種事務隔離級別。

事務型：僅僅在受管理環境中適用。它提供了Repeatable Read事務隔離級別。對於經常被讀但很少修改的數據，可以採用這種隔離類型，因為它可以防止臟讀和不可重復讀這類的並發問題。

讀寫型：提供了Read Committed事務隔離級別。僅僅在非集群的環境中適用。對於經常被讀但很少修改的數據，可以採用這種隔離類型，因為它可以防止臟讀這類的並發問題。

非嚴格讀寫型：不保證緩存與資料庫中數據的一致性。如果存在兩個事務同時訪問緩存中相同數據的可能，必須為該數據配置一個很短的數據過期時間，從而盡量避免臟讀。對於極少被修改，並且允許偶爾臟讀的數據，可以採用這種並發訪問策略。

只讀型：對於從來不會修改的數據，如參考數據，可以使用這種並發訪問策略。

事務型並發訪問策略是事務隔離級別最高，只讀型的隔離級別最低。事務隔離級別越高，並發性能就越低。

什麼樣的數據適合存放到第二級緩存中？

1 很少被修改的數據

2 不是很重要的數據，允許出現偶爾並發的數據

3 不會被並發訪問的數據

4 參考數據

不適合存放到第二級緩存的數據？

1 經常被修改的數據

2 財務數據，絕對不允許出現並發

3 與其他應用共享的數據。

Hibernate的二級緩存

如前所述，Hibernate提供了兩級緩存，第一級是Session的緩存。由於Session對象的生命周期通常對應一個資料庫事務或者一個應用事務，因此它的緩存是事務范圍的緩存。第一級緩存是必需的，不允許而且事實上也無法比卸除。在第一級緩存中，持久化類的每個實例都具有唯一的OID。

第二級緩存是一個可插拔的的緩存插件，它是由SessionFactory負責管理。由於SessionFactory對象的生命周期和應用程序的整個過程對應，因此第二級緩存是進程范圍或者集群范圍的緩存。這個緩存中存放的對象的鬆散數據。第二級對象有可能出現並發問題，因此需要採用適當的並發訪問策略，該策略為被緩存的數據提供了事務隔離級別。緩存適配器用於把具體的緩存實現軟體與Hibernate集成。第二級緩存是可選的，可以在每個類或每個集合的粒度上配置第二級緩存。

Hibernate的二級緩存策略的一般過程如下：

1) 條件查詢的時候，總是發出一條select * from table_name where …. （選擇所有欄位）這樣的SQL語句查詢資料庫，一次獲得所有的數據對象。

2) 把獲得的所有數據對象根據ID放入到第二級緩存中。

3) 當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；查不到，如果配置了二級緩存，那麼從二級緩存中查；查不到，再查詢資料庫，把結果按照ID放入到緩存。

4) 刪除、更新、增加數據的時候，同時更新緩存。

Hibernate的二級緩存策略，是針對於ID查詢的緩存策略，對於條件查詢則毫無作用。為此，Hibernate提供了針對條件查詢的Query緩存。

Hibernate的Query緩存策略的過程如下：

1) Hibernate首先根據這些信息組成一個Query Key，Query Key包括條件查詢的請求一般信息：SQL, SQL需要的參數，記錄范圍（起始位置rowStart，最大記錄個數maxRows)，等。

2) Hibernate根據這個Query Key到Query緩存中查找對應的結果列表。如果存在，那麼返回這個結果列表；如果不存在，查詢資料庫，獲取結果列表，把整個結果列表根據Query Key放入到Query緩存中。

3) Query Key中的SQL涉及到一些表名，如果這些表的任何數據發生修改、刪除、增加等操作，這些相關的Query Key都要從緩存中清空.

㈡ hibernate 設置緩存嗎

hibernate中提供了兩級緩存，一級緩存是Session級別的緩存，它屬於事務范圍的緩存，該級緩存由hibernate管理，應用程序無需干預；二級緩存是SessionFactory級別的緩存，該級緩存可以進行配置和更改，並且可以動態載入和卸載，hibernate還為查詢結果提供了一個查詢緩存，它依賴於二級緩存；
一，緩存的概念
緩存是位於應用程序和永久性數據存儲源之間用於臨時存放復制數據的內存區域，緩存可以降低應用程序之間讀寫永久性數據存儲源的次數，從而提高應用程序的運行性能；
hibernate在查詢數據時，首先會到緩存中查找，如果找到就直接使用，找不到時才從永久性數據存儲源中檢索，因此，把頻繁使用的數據載入到緩存中，可以減少應用程序對永久性數據存儲源的訪問，使應用程序的運行性能得以提升；
二，緩存的范圍
緩存范圍決定了緩存的生命周期，緩存范圍分為3類：
1>事務范圍
緩存只能被當前事務訪問，緩存的生命周期依賴於事務的生命周期，事務結束時，緩存的生命周期也結束了；
2>進程范圍
緩存被進程內的所有事務共享，這些事務會並發訪問緩存，需要對緩存採用必要的事務隔離機制，緩存的生命周期取決與進程的生命周期，進程結束，緩存的生命周期也結束了；
3>集群范圍
緩存被一個或多個計算機的進程共享，緩存中的數據被復制到集群中的每個進行節點，進程間通過遠程通信來保證緩存中數據的一致性；
在查詢時，如果在事務范圍內的緩存中沒有找到，可以到進程范圍或集群范圍的緩存中查找，如果還沒找到，則到資料庫中查詢；
三，Hibernate中的第一級緩存
Hibernate的一級緩存由Session提供，只存在於Session的生命周期中，當應用程序調用Session介面的save(),update(),saveOrupDate(),get(),load()或者Query和Criteria實例的list(),iterate()等方法時，如果Session緩存中沒有相應的對象，hibernate就會把對象加入到一級緩存中，當session關閉時，該Session所管理的一級緩存也會立即被清除；

㈢ hibernate如何進行緩存

緩存是位於應用程序與物理數據源之間，用於臨時存放復制數據的內存區域，目的是為了減少應用程序對物理數據源訪問的次數，從而提高應用程序的運行性能.
Hibernate在查詢數據時，首先到緩存中去查找，如果找到就直接使用，找不到的時候就會從物理數據源中檢索，所以，把頻繁使用的數據載入到緩存區後，就可以大大減少應用程序對物理數據源的訪問，使得程序的運行性能明顯的提升.

Hibernate緩存分類：

Session緩存，一級緩存.

SessionFactory的緩存分為內置緩存和外置緩存.內置緩存中存放的是SessionFactory對象的一些集合屬性包含的數據(映射元素據及預定義SQL語句等),對於應用程序來說,它是只讀的.外置緩存中存放的是資料庫數據的副本,其作用和一級緩存類似.二級緩存除了以內存作為存儲介質外,還可以選用硬碟等外部存儲設備.

Hibernate的緩存范圍

Hibernate的一級緩存和二級緩存都位於均位於持久層,且均用於存放資料庫數據的副本,最大的區別就是緩存的范圍各不一樣.

緩存的范圍分為3類:

1.事務范圍
事務范圍的緩存只能被當前事務訪問,每個事務都有各自的緩存,緩存內的數據通常採用相互關聯的對象形式.緩存的生命周期依賴於事務的生命周期,只有當事務結束時,緩存的生命周期才會結束.事務范圍的緩存使用內存作為存儲介質,一級緩存就屬於事務范圍.
2.應用范圍
應用程序的緩存可以被應用范圍內的所有事務共享訪問.緩存的生命周期依賴於應用的生命周期,只有當應用結束時,緩存的生命周期才會結束.應用范圍的緩存可以使用內存或硬碟作為存儲介質,二級緩存就屬於應用范圍.
3.集群范圍
在集群環境中,緩存被一個機器或多個機器的進程共享,緩存中的數據被復制到集群環境中的每個進程節點,進程間通過遠程通信來保證緩存中的數據的一致,緩存中的數據通常採用對象的鬆散數據形式.

Hibernate的緩存管理

一級緩存的管理:

evit(Object obj) 將指定的持久化對象從一級緩存中清除,釋放對象所佔用的內存資源,指定對象從持久化狀態變為脫管狀態,從而成為游離對象.
clear() 將一級緩存中的所有持久化對象清除,釋放其佔用的內存資源
contains(Object obj) 判斷指定的對象是否存在於一級緩存中.
flush() 刷新一級緩存區的內容,使之與資料庫數據保持同步.

二級緩存的管理:

evict(Class arg0, Serializable arg1) 將某個類的指定ID的持久化對象從二級緩存中清除,釋放對象所佔用的資源.
java代碼 sessionFactory.evict(Customer.class, new Integer(1)); sessionFactory.evict(Customer.class, new Integer(1));
evict(Class arg0) 將指定類的所有持久化對象從二級緩存中清除,釋放其佔用的內存資源.
Java代碼 sessionFactory.evict(Customer.class); sessionFactory.evict(Customer.class);
evictCollection(String arg0) 將指定類的所有持久化對象的指定集合從二級緩存中清除,釋放其佔用的內存資源.
Java代碼 sessionFactory.evictCollection("Customer.orders"); sessionFactory.evictCollection("Customer.orders");

Hibernate的二級緩存的配置

首先,不是所有的數據都適合放在二級緩存中,看一下,什麼樣的數據適合放在二級緩存中來?什麼樣的數據不適合放在二級緩存中來?
下面這幾種情況就不適合載入到二級緩存中:
1.經常被修改的數據
2.絕對不允許出現並發訪問的數據
3.與其他應用共享的數據
下面這己種情況合適載入到二級緩存中:
1.數據更新頻率低
2.允許偶爾出現並發問題的非重要數據
3.不會被並發訪問的數據
4.常量數據
5.不會被第三方修改的數據

Hibernate的二級緩存功能是靠配置二級緩存插件來實現的,Hibernate為了集成這些插件,Hibernate提供了org.hibernate.cache.CacheProvider借口,它充當緩存插件與Hibernate之間的適配器 .

常用的二級緩存插件
EHCache org.hibernate.cache.EhCacheProvider
OSCache org.hibernate.cache.OSCacheProvider
SwarmCahe org.hibernate.cache.SwarmCacheProvider
JBossCache org.hibernate.cache.TreeCacheProvider

簡單介紹一下EHCache的配置
hibernate.cfg.xml
Xml代碼 <hibernate-configuration> <session-factory> <!-- 設置二級緩存插件EHCache的Provider類--> <property name="hibernate.cache.provider_class"> org.hibernate.cache.EhCacheProvider </property> <!-- 啟動"查詢緩存" --> <property name="hibernate.cache.use_query_cache"> true </property> </session-factory> </hibernate-configuration> <hibernate-configuration> <session-factory> <!-- 設置二級緩存插件EHCache的Provider類--> <property name="hibernate.cache.provider_class"> org.hibernate.cache.EhCacheProvider </property> <!-- 啟動"查詢緩存" --> <property name="hibernate.cache.use_query_cache"> true </property> </session-factory> </hibernate-configuration>

ehcache.xml

Xml代碼 <ehcache> <!-- maxElementsInMemory為緩存對象的最大數目, eternal設置是否永遠不過期,timeToIdleSeconds對象處於空閑狀態的最多秒數,timeToLiveSeconds對象處於緩存狀態的最多秒數 --> <diskStore path="java.io.tmpdir"/> <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true"/> </ehcache> <ehcache> <!-- maxElementsInMemory為緩存對象的最大數目, eternal設置是否永遠不過期,timeToIdleSeconds對象處於空閑狀態的最多秒數,timeToLiveSeconds對象處於緩存狀態的最多秒數 --> <diskStore path="java.io.tmpdir"/> <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true"/></ehcache>

****.hbm.xml

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> <class> <!-- 設置該持久化類的二級緩存並發訪問策略 read-only read-write nonstrict-read-write transactional--> <cache usage="read-write"/> </class> </hibernate-mapping> <?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> <class> <!-- 設置該持久化類的二級緩存並發訪問策略 read-only read-write nonstrict-read-write transactional--> <cache usage="read-write"/> </class> </hibernate-mapping>

㈣ 如何配置hibernate二級緩存

答案轉載自：http://blog.csdn.net/runming56/article/details/8574047

如何在程序里使用二級緩存：
首先在hibernate.cfg.xml開啟二級緩存

Xml代碼

<hibernate-configuration>
<session-factory>

......

<!-- 開啟二級緩存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 啟動"查詢緩存"如果想緩存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法獲得的數據結果集,必須配置此項-->
<property name="hibernate.cache.use_query_cache">true</property>
<!-- 設置二級緩存插件EHCache的Provider類-->
<!-- <property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property> -->
<!-- 二級緩存區域名的前綴 -->
<!--<property name="hibernate.cache.region_prefix">test</property>-->
<!-- 高速緩存提供程序 -->
<property name="hibernate.cache.region.factory_class">
net.sf.ehcache.hibernate.EhCacheRegionFactory
</property>
<!-- Hibernate4以後都封裝到org.hibernate.cache.ehcache.EhCacheRegionFactory -->
<!-- 指定緩存配置文件位置 -->
<!-- <property name="hibernate.cache.provider_configuration_file_resource_path">
ehcache.xml
</property> -->
<!-- 強制Hibernate以更人性化的格式將數據存入二級緩存 -->
<property name="hibernate.cache.use_structured_entries">true</property>

<!-- Hibernate將收集有助於性能調節的統計數據 -->
<property name="hibernate.generate_statistics">true</property>

......

</session-factory>
</hibernate-configuration>

然後是ehcache配置（ehcache.xml）
cache參數詳解：
● name:指定區域名
● maxElementsInMemory ：緩存在內存中的最大數目
● maxElementsOnDisk：緩存在磁碟上的最大數目
● eternal ：設置是否永遠不過期
● overflowToDisk ： 硬碟溢出數目
● timeToIdleSeconds ：對象處於空閑狀態的最多秒數後銷毀
● timeToLiveSeconds ：對象處於緩存狀態的最多秒數後銷毀
● memoryStoreEvictionPolicy:緩存演算法，有LRU（默認）、LFU、LFU

關於緩存演算法，常見有三種：
● LRU：（Least Rencently Used）新來的對象替換掉使用時間算最近很少使用的對象
● LFU：（Least Frequently Used）替換掉按命中率高低算比較低的對象
● LFU：（First In First Out）把最早進入二級緩存的對象替換掉

Xml代碼

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--如果緩存中的對象存儲超過指定的緩存數量的對象存儲的磁碟地址-->
<diskStore path="D:/ehcache"/>

<!-- 默認cache：如果沒有對應的特定區域的緩存，就使用默認緩存 -->
<defaultCache maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="false"/>
<!-- 指定區域cache：通過name指定，name對應到Hibernate中的區域名即可-->
<cache name="cn.javass.h3test.model.UserModel"
eternal="false"
maxElementsInMemory="100"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200"
overflowToDisk="false">
</cache>

</ehcache>

在每個實體的hbm文件中配置cache元素，usage可以是read-only或者是read-write等4種。

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>
<class>
<!-- 設置該持久化類的二級緩存並發訪問策略 read-only read-write nonstrict-read-write transactional-->
<class name="cn.java.test.model.User" table="TBL_USER">
<cache usage="read-write"/>
......
</class>
</hibernate-mapping>

也可以用Hibernate註解配置緩存實體類

Java代碼

@Entity
@Table
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User implements Serializable {
private static final long serialVersionUID = -5121812640999313420L;
private Integer id;
private String name;

......
}

㈤ hibernate二級緩存設置問題

<property
name="hibernate.cache.use_second_level_cache">true</property>
<property
name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
前一句是打開二級緩存，後一句是啟用第三方緩存產品（可改變，上面eache是hibernate官方默認的第三方緩存產品）
緩存是否實用，要看你的需求，
如果你的系統，瀏覽的人數比較多，但是增刪的比較少，緩存的功勞非常大
如果你的系統即時性非常強，那麼緩存的命中率就比較低，同時更新數據時，hibernate需要額外提供資源維護緩存與數據的一致

㈥ hibernate緩存的詳細配置

很多人對二級緩存都不太了解，或者是有錯誤的認識，我一直想寫一篇文章介紹一下hibernate的二級緩存的，今天終於忍不住了。
我的經驗主要來自hibernate2.1版本，基本原理和3.0、3.1是一樣的，請原諒我的頑固不化。

hibernate的session提供了一級緩存，每個session，對同一個id進行兩次load，不會發送兩條sql給資料庫，但是session關閉的時候，一級緩存就失效了。

二級緩存是SessionFactory級別的全局緩存，它底下可以使用不同的緩存類庫，比如ehcache、oscache等，需要設置hibernate.cache.provider_class，我們這里用ehcache，在2.1中就是
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
如果使用查詢緩存，加上
hibernate.cache.use_query_cache=true

緩存可以簡單的看成一個Map，通過key在緩存裡面找value。

Class的緩存
對於一條記錄，也就是一個PO來說，是根據ID來找的，緩存的key就是ID，value是POJO。無論list，load還是iterate，只要讀出一個對象，都會填充緩存。但是list不會使用緩存，而iterate會先取資料庫select id出來，然後一個id一個id的load，如果在緩存裡面有，就從緩存取，沒有的話就去資料庫load。假設是讀寫緩存，需要設置：
<cache usage="read-write"/>
如果你使用的二級緩存實現是ehcache的話，需要配置ehcache.xml
<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
其中eternal表示緩存是不是永遠不超時，timeToLiveSeconds是緩存中每個元素（這里也就是一個POJO）的超時時間，如果eternal="false"，超過指定的時間，這個元素就被移走了。timeToIdleSeconds是發呆時間，是可選的。當往緩存裡面put的元素超過500個時，如果overflowToDisk="true"，就會把緩存中的部分數據保存在硬碟上的臨時文件裡面。
每個需要緩存的class都要這樣配置。如果你沒有配置，hibernate會在啟動的時候警告你，然後使用defaultCache的配置，這樣多個class會共享一個配置。
當某個ID通過hibernate修改時，hibernate會知道，於是移除緩存。
這樣大家可能會想，同樣的查詢條件，第一次先list，第二次再iterate，就可以使用到緩存了。實際上這是很難的，因為你無法判斷什麼時候是第一次，而且每次查詢的條件通常是不一樣的，假如資料庫裡面有100條記錄，id從1到100，第一次list的時候出了前50個id，第二次iterate的時候卻查詢到30至70號id，那麼30-50是從緩存裡面取的，51到70是從資料庫取的，共發送1+20條sql。所以我一直認為iterate沒有什麼用，總是會有1+N的問題。
（題外話：有說法說大型查詢用list會把整個結果集裝入內存，很慢，而iterate只select id比較好，但是大型查詢總是要分頁查的，誰也不會真的把整個結果集裝進來，假如一頁20條的話，iterate共需要執行21條語句，list雖然選擇若干欄位，比iterate第一條select id語句慢一些，但只有一條語句，不裝入整個結果集hibernate還會根據資料庫方言做優化，比如使用mysql的limit，整體看來應該還是list快。）
如果想要對list或者iterate查詢的結果緩存，就要用到查詢緩存了

查詢緩存
首先需要配置hibernate.cache.use_query_cache=true
如果用ehcache，配置ehcache.xml，注意hibernate3.0以後不是net.sf的包名了
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
然後
query.setCacheable(true);//激活查詢緩存
query.setCacheRegion("myCacheRegion");//指定要使用的cacheRegion，可選
第二行指定要使用的cacheRegion是myCacheRegion，即你可以給每個查詢緩存做一個單獨的配置，使用setCacheRegion來做這個指定，需要在ehcache.xml裡面配置它：
<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />
如果省略第二行，不設置cacheRegion的話，那麼會使用上面提到的標准查詢緩存的配置，也就是net.sf.hibernate.cache.StandardQueryCache

對於查詢緩存來說，緩存的key是根據hql生成的sql，再加上參數，分頁等信息（可以通過日誌輸出看到，不過它的輸出不是很可讀，最好改一下它的代碼）。
比如hql：
from Cat c where c.name like ?
生成大致如下的sql：
select * from cat c where c.name like ?
參數是"tiger%"，那麼查詢緩存的key*大約*是這樣的字元串（我是憑記憶寫的，並不精確，不過看了也該明白了）：
select * from cat c where c.name like ? , parameter:tiger%
這樣，保證了同樣的查詢、同樣的參數等條件下具有一樣的key。
現在說說緩存的value，如果是list方式的話，value在這里並不是整個結果集，而是查詢出來的這一串ID。也就是說，不管是list方法還是iterate方法，第一次查詢的時候，它們的查詢方式很它們平時的方式是一樣的，list執行一條sql，iterate執行1+N條，多出來的行為是它們填充了緩存。但是到同樣條件第二次查詢的時候，就都和iterate的行為一樣了，根據緩存的key去緩存裡面查到了value，value是一串id，然後在到class的緩存裡面去一個一個的load出來。這樣做是為了節約內存。
可以看出來，查詢緩存需要打開相關類的class緩存。list和iterate方法第一次執行的時候，都是既填充查詢緩存又填充class緩存的。
這里還有一個很容易被忽視的重要問題，即打開查詢緩存以後，即使是list方法也可能遇到1+N的問題！相同條件第一次list的時候，因為查詢緩存中找不到，不管class緩存是否存在數據，總是發送一條sql語句到資料庫獲取全部數據，然後填充查詢緩存和class緩存。但是第二次執行的時候，問題就來了，如果你的class緩存的超時時間比較短，現在class緩存都超時了，但是查詢緩存還在，那麼list方法在獲取id串以後，將會一個一個去資料庫load！因此，class緩存的超時時間一定不能短於查詢緩存設置的超時時間！如果還設置了發呆時間的話，保證class緩存的發呆時間也大於查詢的緩存的生存時間。這里還有其他情況，比如class緩存被程序強制evict了，這種情況就請自己注意了。

另外，如果hql查詢包含select字句，那麼查詢緩存裡面的value就是整個結果集了。

當hibernate更新資料庫的時候，它怎麼知道更新哪些查詢緩存呢？
hibernate在一個地方維護每個表的最後更新時間，其實也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的緩存配置裡面。
當通過hibernate更新的時候，hibernate會知道這次更新影響了哪些表。然後它更新這些表的最後更新時間。每個緩存都有一個生成時間和這個緩存所查詢的表，當hibernate查詢一個緩存是否存在的時候，如果緩存存在，它還要取出緩存的生成時間和這個緩存所查詢的表，然後去查找這些表的最後更新時間，如果有一個表在生成時間後更新過了，那麼這個緩存是無效的。
可以看出，只要更新過一個表，那麼凡是涉及到這個表的查詢緩存就失效了，因此查詢緩存的命中率可能會比較低。

Collection緩存
需要在hbm的collection裡面設置
<cache usage="read-write"/>
假如class是Cat，collection叫children，那麼ehcache裡面配置
<cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" />
Collection的緩存和前面查詢緩存的list一樣，也是只保持一串id，但它不會因為這個表更新過就失效，一個collection緩存僅在這個collection裡面的元素有增刪時才失效。
這樣有一個問題，如果你的collection是根據某個欄位排序的，當其中一個元素更新了該欄位時，導致順序改變時，collection緩存裡面的順序沒有做更新。

緩存策略
只讀緩存（read-only）：沒有什麼好說的
讀/寫緩存（read-write）:程序可能要的更新數據
不嚴格的讀/寫緩存（nonstrict-read-write）：需要更新數據，但是兩個事務更新同一條記錄的可能性很小，性能比讀寫緩存好
事務緩存（transactional）：緩存支持事務，發生異常的時候，緩存也能夠回滾，只支持jta環境，這個我沒有怎麼研究過

讀寫緩存和不嚴格讀寫緩存在實現上的區別在於，讀寫緩存更新緩存的時候會把緩存裡面的數據換成一個鎖，其他事務如果去取相應的緩存數據，發現被鎖住了，然後就直接取資料庫查詢。
在hibernate2.1的ehcache實現中，如果鎖住部分緩存的事務發生了異常，那麼緩存會一直被鎖住，直到60秒後超時。
不嚴格讀寫緩存不鎖定緩存中的數據。

使用二級緩存的前置條件
你的hibernate程序對資料庫有獨占的寫訪問權，其他的進程更新了資料庫，hibernate是不可能知道的。你操作資料庫必需直接通過hibernate，如果你調用存儲過程，或者自己使用jdbc更新資料庫，hibernate也是不知道的。hibernate3.0的大批量更新和刪除是不更新二級緩存的，但是據說3.1已經解決了這個問題。
這個限制相當的棘手，有時候hibernate做批量更新、刪除很慢，但是你卻不能自己寫jdbc來優化，很郁悶吧。
SessionFactory也提供了移除緩存的方法，你一定要自己寫一些JDBC的話，可以調用這些方法移除緩存，這些方法是：
void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.
不過我不建議這樣做，因為這樣很難維護。比如你現在用JDBC批量更新了某個表，有3個查詢緩存會用到這個表，用evictQueries(String cacheRegion)移除了3個查詢緩存，然後用evict(Class persistentClass)移除了class緩存，看上去好像完整了。不過哪天你添加了一個相關查詢緩存，可能會忘記更新這里的移除代碼。如果你的jdbc代碼到處都是，在你添加一個查詢緩存的時候，還知道其他什麼地方也要做相應的改動嗎？

----------------------------------------------------

總結：
不要想當然的以為緩存一定能提高性能，僅僅在你能夠駕馭它並且條件合適的情況下才是這樣的。hibernate的二級緩存限制還是比較多的，不方便用jdbc可能會大大的降低更新性能。在不了解原理的情況下亂用，可能會有1+N的問題。不當的使用還可能導致讀出臟數據。
如果受不了hibernate的諸多限制，那麼還是自己在應用程序的層面上做緩存吧。
在越高的層面上做緩存，效果就會越好。就好像盡管磁碟有緩存，資料庫還是要實現自己的緩存，盡管資料庫有緩存，咱們的應用程序還是要做緩存。因為底層的緩存它並不知道高層要用這些數據干什麼，只能做的比較通用，而高層可以有針對性的實現緩存，所以在更高的級別上做緩存，效果也要好些吧。

㈦ 如何實現hibernate的緩存機制

為了提高系統性能，hibernate也使用了緩存機制。在hibernate框架中，主要包含兩個方面的緩存，一級緩存和二級緩存。hibernate緩存的作用主要表現在以下兩個方面： 1) 通過主鍵(ID)載入數據的時候 .2) 延遲載入中。


一級緩存：hibernate的一級緩存是由session提供的，因此它只存在session的生命周期中。也就是說session關閉的時候該
session所管理的一級緩存也隨之被清除。hibernate的一級緩存是session所內置的，默認開啟，不能被卸載，也不能進行任何配置。在緩
存中的對象,具有持久性,session對象負責管理.一級緩存的優點是使用同一個session對象多次查詢同一個數據對象,僅對資料庫查詢一次。一級
緩存採用的是Key-Value的MAP方式來實現的。在緩存實體對象時，對象的主關鍵字ID是MAP的Key，實體對象就是對象的值。所以說一級緩存是
以實體對象為單位進行存儲的。訪問的時候使用的是主鍵關鍵字ID。一級緩存使用的是自動維護的功能。但可以通過session提供的手動方法對一級緩存的
管理進行手動干預。evict()方法用於將某個對象從session的一級緩存中清除。clear()方法用於將session緩存中的方法全部清除。

二級緩存：二級緩存的實現原理與一級緩存是一樣的。也是通過Key-Value的Map來實現對對象的緩存。二級緩存是作用在
SessionFactory范圍內的。因此它它可被所有的Session對象所共享。需要注意的是放入緩存中的數據不能有第三方的應用對數據進行修改。

二級緩存默認關閉，需要程序員手動開啟。首先導入ehcache.jar二級緩存包。然後，在src下添加ehcache.xml配置，同時，在
hibernate.cfg.xml中啟用二級緩存<property
name="hibernate.cache.use_second_level_cache">
true</property><property
name="hibernate.cache.provider_class">
net.sf.ehcache.hibernate.EhCacheProvider</property>。第三：指定使用二級緩存緩存哪
種類型的對象，在hbm.xml中添加<cache region="sampleCache1" usage="read-only"/>

㈧ hibernate 二級緩存如何使用，還有查詢緩存

有session緩存又叫一級緩存，sessionFactory緩存；其中sessionFactory緩存又分為兩種：一種是內置緩存，一種是外置緩存即二級緩存，存放資料庫數據。
如何使用：
session緩存不需要任何設置，在你openSession時它就自己開始工作了。
外置緩存即二級緩存需要在xml文件中進行配置。
Hibernate緩存分為二級，
第一級存放於session中稱為一級緩存，默認帶有且不能卸載。
第二級是由sessionFactory控制的進程級緩存。是全局共享的緩存，凡是會調用二級緩存的查詢方法 都會從中受益。只有經正確的配置後二級緩存才會發揮作用。同時在進行條件查詢時必須使用相應的方法才能從緩存中獲取數據。比如Query.iterate()方法、load、get方法等。必須注意的是session.find方法永遠是從資料庫中獲取數據，不會從二級緩存中獲取數據，即便其中有其所需要的數據也是如此。
查詢時使用緩存的實現過程為：首先查詢一級緩存中是否具有需要的數據，如果沒有，查詢二級緩存，如果二級緩存中也沒有，此時再執行查詢資料庫的工作。要注意的是：此3種方式的查詢速度是依次降低的。
存在的問題
一級緩存的問題以及使用二級緩存的原因
因為Session的生命期往往很短，存在於Session內部的第一級最快緩存的生命期當然也很短，所以第一級緩存的命中率是很低的。其對系統性能的改善也是很有限的。當然，這個Session內部緩存的主要作用是保持Session內部數據狀態同步。並非是hibernate為了大幅提高系統性能所提供的。
為了提高使用hibernate的性能，除了常規的一些需要注意的方法比如：
使用延遲載入、迫切外連接、查詢過濾等以外，還需要配置hibernate的二級緩存。其對系統整體性能的改善往往具有立竿見影的效果！
（經過自己以前作項目的經驗，一般會有3~4倍的性能提高）

㈨ hibernate的緩存機制舉例

為了提高系統性能，hibernate也使用了緩存機制。在hibernate框架中，主要包含兩個方面的緩存，一級緩存和二級緩存。hibernate緩存的作用主要表現在以下兩個方面： 1) 通過主鍵(ID)載入數據的時候 .2) 延遲載入中。


一級緩存：hibernate的一級緩存是由session提供的，因此它只存在session的生命周期中。也就是說session關閉的時候該
session所管理的一級緩存也隨之被清除。hibernate的一級緩存是session所內置的，默認開啟，不能被卸載，也不能進行任何配置。在緩
存中的對象,具有持久性,session對象負責管理.一級緩存的優點是使用同一個session對象多次查詢同一個數據對象,僅對資料庫查詢一次。一級
緩存採用的是Key-Value的MAP方式來實現的。在緩存實體對象時，對象的主關鍵字ID是MAP的Key，實體對象就是對象的值。所以說一級緩存是
以實體對象為單位進行存儲的。訪問的時候使用的是主鍵關鍵字ID。一級緩存使用的是自動維護的功能。但可以通過session提供的手動方法對一級緩存的
管理進行手動干預。evict()方法用於將某個對象從session的一級緩存中清除。clear()方法用於將session緩存中的方法全部清除。

二級緩存：二級緩存的實現原理與一級緩存是一樣的。也是通過Key-Value的Map來實現對對象的緩存。二級緩存是作用在
SessionFactory范圍內的。因此它它可被所有的Session對象所共享。需要注意的是放入緩存中的數據不能有第三方的應用對數據進行修改。

二級緩存默認關閉，需要程序員手動開啟。首先導入ehcache.jar二級緩存包。然後，在src下添加ehcache.xml配置，同時，在
hibernate.cfg.xml中啟用二級緩存<property
name="hibernate.cache.use_second_level_cache">
true</property><property
name="hibernate.cache.provider_class">
net.sf.ehcache.hibernate.EhCacheProvider</property>。第三：指定使用二級緩存緩存哪
種類型的對象，在hbm.xml中添加<cache region="sampleCache1" usage="read-only"/>

㈩ 誰能幫我解釋下Hibernate 一級緩存 二級緩存 以及查詢緩存

一級緩存
為session級別的緩存，為
hibernate
內置緩存，你從資料庫load或get數據的時候會先去一級緩存上找。如果找到，則不會從資料庫中存，否則從資料庫中取。一級緩存會在session關閉時自動清除。
二級緩存為
SessionFactory
級別的緩存，要使用第三方二級緩存組件，不同session可以共享二級緩存中的數據！
查詢緩存就是hql或
sql語句
要相同，否則無法命中數據