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怎麼實現緩存

一、why（為什麼要用Hibernate緩存？）

Hibernate是一個持久層框架，經常訪問物理資料庫。

為了降低應用程序對物理數據源訪問的頻次，從而提高應用程序的運行性能。

緩存內的數據是對物理數據源中的數據的復制，應用程序在運行時從緩存讀寫數據，在特定的時刻或事件會同步緩存和物理數據源的數據。

二、what（Hibernate緩存原理是怎樣的？）Hibernate緩存包括兩大類：Hibernate一級緩存和Hibernate二級緩存。

1.Hibernate一級緩存又稱為「Session的緩存」。

Session內置不能被卸載，Session的緩存是事務范圍的緩存（Session對象的生命周期通常對應一個資料庫事務或者一個應用事務）。

一級緩存中，持久化類的每個實例都具有唯一的OID。

2.Hibernate二級緩存又稱為「SessionFactory的緩存」。

由於SessionFactory對象的生命周期和應用程序的整個過程對應，因此Hibernate二級緩存是進程范圍或者集群范圍的緩存，有可能出現並發問題，因此需要採用適當的並發訪問策略，該策略為被緩存的數據提供了事務隔離級別。

第二級緩存是可選的，是一個可配置的插件，默認下SessionFactory不會啟用這個插件。

Hibernate提供了org.hibernate.cache.CacheProvider介面,它充當緩存插件與Hibernate之間的適配器。

什麼樣的數據適合存放到第二級緩存中？
1) 很少被修改的數據
2) 不是很重要的數據，允許出現偶爾並發的數據
3) 不會被並發訪問的數據
4) 常量數據
不適合存放到第二級緩存的數據？
1) 經常被修改的數據
2) 絕對不允許出現並發訪問的數據，如財務數據，絕對不允許出現並發
3) 與其他應用共享的數據。

3.Session的延遲載入實現要解決兩個問題：正常關閉連接和確保請求中訪問的是同一個session。

Hibernate session就是java.sql.Connection的一層高級封裝，一個session對應了一個Connection。

http請求結束後正確的關閉session（過濾器實現了session的正常關閉）；延遲載入必須保證是同一個session（session綁定在ThreadLocal）。

4.Hibernate查找對象如何應用緩存？
當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；

查不到，如果配置了二級緩存，那麼從二級緩存中查；

如果都查不到，再查詢資料庫，把結果按照ID放入到緩存刪除、更新、增加數據的時候，同時更新緩存。

5.一級緩存與二級緩存的對比圖。

一級緩存

二級緩存

存放數據的形式

相互關聯的持久化對象

對象的散裝數據

緩存的范圍

事務范圍，每個事務都擁有單獨的一級緩存

進程范圍或集群范圍，緩存被同一個進程或集群范圍內所有事務共享

並發訪問策略

由於每個事務都擁有單獨的一級緩存不會出現並發問題，因此無須提供並發訪問策略

由於多個事務會同時訪問二級緩存中的相同數據，因此必須提供適當的並發訪問策略，來保證特定的事務隔離級別

數據過期策略

處於一級緩存中的對象永遠不會過期，除非應用程序顯示清空或者清空特定對象

必須提供數據過期策略，如基於內存的緩存中對象的最大數目，允許對象處於緩存中的最長時間，以及允許對象處於緩存中的最長空閑時間

物理介質

內存

內存和硬碟，對象的散裝數據首先存放到基於內存的緩存中，當內存中對象的數目達到數據過期策略的maxElementsInMemory值，就會把其餘的對象寫入基於硬碟的緩存中

緩存軟體實現

在Hibernate的Session的實現中包含

由第三方提供，Hibernate僅提供了緩存適配器，用於把特定的緩存插件集成到Hibernate中

啟用緩存的方式

只要通過Session介面來執行保存，更新，刪除，載入，查詢，Hibernate就會啟用一級緩存，對於批量操作，如不希望啟用一級緩存，直接通過JDBCAPI來執行

用戶可以再單個類或類的單個集合的粒度上配置第二級緩存，如果類的實例被經常讀，但很少被修改，就可以考慮使用二級緩存，只有為某個類或集合配置了二級緩存，Hibernate在運行時才會把它的實例加入到二級緩存中

用戶管理緩存的方式

一級緩存的物理介質為內存，由於內存的容量有限，必須通過恰當的檢索策略和檢索方式來限制載入對象的數目，Session的evit（）方法可以顯示的清空緩存中特定對象，但不推薦

二級緩存的物理介質可以使內存和硬碟，因此第二級緩存可以存放大容量的數據，數據
過期策略的maxElementsInMemory屬性可以控制內存中的對象數目，管理二級緩存主要包括兩個方面：選擇需要使用第二級緩存的持久化類，設
置合適的並發訪問策略；選擇緩存適配器，設置合適的數據過期策略。SessionFactory的evit（）方法也可以顯示的清空緩存中特定對象，但不
推薦

三、how（Hibernate的緩存機制如何應用？）

1. 一級緩存的管理:

evit(Object obj) 將指定的持久化對象從一級緩存中清除,釋放對象所佔用的內存資源,指定對象從持久化狀態變為脫管狀態,從而成為游離對象。

clear() 將一級緩存中的所有持久化對象清除,釋放其佔用的內存資源。

contains(Object obj) 判斷指定的對象是否存在於一級緩存中。

flush() 刷新一級緩存區的內容,使之與資料庫數據保持同步。

2.一級緩存應用： save()。當session對象調用save()方法保存一個對象後，該對象會被放入到session的緩存中。
get()和load()。當session對象調用get()或load()方法從資料庫取出一個對象後，該對象也會被放入到session的緩存中。
使用HQL和QBC等從資料庫中查詢數據。

public class Client
{
public static void main(String[] args)
{
Session session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
try
{
/*開啟一個事務*/
tx = session.beginTransaction();
/*從資料庫中獲取id=""的Customer對象*/
Customer customer1 = (Customer)session.get(Customer.class, "");
System.out.println("customer.getUsername is"+customer1.getUsername());
/*事務提交*/
tx.commit();

System.out.println("-------------------------------------");

/*開啟一個新事務*/
tx = session.beginTransaction();
/*從資料庫中獲取id=""的Customer對象*/
Customer customer2 = (Customer)session.get(Customer.class, "");
System.out.println("customer2.getUsername is"+customer2.getUsername());
/*事務提交*/
tx.commit();

System.out.println("-------------------------------------");

/*比較兩個get()方法獲取的對象是否是同一個對象*/
System.out.println("customer1 == customer2 result is "+(customer1==customer2));
}
catch (Exception e)
{
if(tx!=null)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}

結果
Hibernate:
select
customer0_.id as id0_0_,
customer0_.username as username0_0_,
customer0_.balance as balance0_0_
from
customer customer0_
where
customer0_.id=?
customer.getUsername islisi
-------------------------------------
customer2.getUsername islisi
-------------------------------------
customer1 == customer2 result is true

輸出結果中只包含了一條SELECT SQL語句，而且customer1 == customer2 result is
true說明兩個取出來的對象是同一個對象。其原理是：第一次調用get()方法，
Hibernate先檢索緩存中是否有該查找對象，發現沒有，Hibernate發送SELECT語句到資料庫中取出相應的對象，然後將該對象放入緩存
中，以便下次使用，第二次調用get()方法，Hibernate先檢索緩存中是否有該查找對象，發現正好有該查找對象，就從緩存中取出來，不再去資料庫
中檢索。

3.二級緩存的管理：

evict(Class arg0, Serializable arg1)將某個類的指定ID的持久化對象從二級緩存中清除,釋放對象所佔用的資源。

sessionFactory.evict(Customer.class, new Integer(1));

evict(Class arg0) 將指定類的所有持久化對象從二級緩存中清除,釋放其佔用的內存資源。

sessionFactory.evict(Customer.class);

evictCollection(String arg0) 將指定類的所有持久化對象的指定集合從二級緩存中清除,釋放其佔用的內存資源。

sessionFactory.evictCollection("Customer.orders");

4.二級緩存的配置

常用的二級緩存插件

EHCache org.hibernate.cache.EhCacheProvider

OSCache org.hibernate.cache.OSCacheProvider

SwarmCahe org.hibernate.cache.SwarmCacheProvider

JBossCache org.hibernate.cache.TreeCacheProvider

<!-- EHCache的配置,hibernate.cfg.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>

<!-- ehcache.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--
緩存到硬碟的路徑
-->
<diskStore path="d:/ehcache"></diskStore>
<!--
默認設置
maxElementsInMemory : 在內存中最大緩存的對象數量。
eternal : 緩存的對象是否永遠不變。
timeToIdleSeconds ：可以操作對象的時間。
timeToLiveSeconds ：緩存中對象的生命周期，時間到後查詢數據會從資料庫中讀取。
overflowToDisk ：內存滿了，是否要緩存到硬碟。
-->
<defaultCache maxElementsInMemory="200" eternal="false"
timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></defaultCache>
<!--
指定緩存的對象。
下面出現的的屬性覆蓋上面出現的，沒出現的繼承上面的。
-->
<cache name="com.suxiaolei.hibernate.pojos.Order" maxElementsInMemory="200" eternal="false"
timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></cache>
</ehcache>

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

若存在一對多的關系，想要在在獲取一方的時候將關聯的多方緩存起來，需要在集合屬性下添加<cache>子標簽，這里需要將關聯的對象的hbm文件中必須在存在<class>標簽下也添加<cache>標簽，不然Hibernate只會緩存OID。

<hibernate-mapping>
<class name="com.suxiaolei.hibernate.pojos.Customer" table="customer">
<!-- 主鍵設置 -->
<id name="id" type="string">
<column name="id"></column>
<generator class="uuid"></generator>
</id>

<!-- 屬性設置 -->
<property name="username" column="username" type="string"></property>
<property name="balance" column="balance" type="integer"></property>

<set name="orders" inverse="true" cascade="all" lazy="false" fetch="join">
<cache usage="read-only"/>
<key column="customer_id" ></key>
<one-to-many class="com.suxiaolei.hibernate.pojos.Order"/>
</set>

</class>
</hibernate-mapping>

『叄』 怎麼理解hibernate的緩存機制

首先我們來探討一下N+1的問題，我們先通過一個例子來看一下，什麼是N+1問題：
list()獲得對象：

/**
* 此時會發出一條sql，將30個學生全部查詢出來
*/
List<Student> ls = (List<Student>)session.createQuery("from Student")
.setFirstResult(0).setMaxResults(30).list();
Iterator<Student> stus = ls.iterator();
for(;stus.hasNext();)
{
Student stu = (Student)stus.next();
System.out.println(stu.getName());
}

如果通過list()方法來獲得對象，毫無疑問，hibernate會發出一條sql語句，將所有的對象查詢出來，這點相信大家都能理解
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

那麼，我們再來看看iterator()這種情況
iterator()獲得對象

/**
* 如果使用iterator方法返回列表，對於hibernate而言，它僅僅只是發出取id列表的sql
* 在查詢相應的具體的某個學生信息時，會發出相應的SQL去取學生信息
* 這就是典型的N+1問題
* 存在iterator的原因是，有可能會在一個session中查詢兩次數據，如果使用list每一次都會把所有的對象查詢上來
* 而是要iterator僅僅只會查詢id，此時所有的對象已經存儲在一級緩存(session的緩存)中，可以直接獲取
*/
Iterator<Student> stus = (Iterator<Student>)session.createQuery("from Student")
.setFirstResult(0).setMaxResults(30).iterate();
for(;stus.hasNext();)
{
Student stu = (Student)stus.next();
System.out.println(stu.getName());
}

在執行完上述的測試用例後，我們來看看控制台的輸出，看會發出多少條 sql 語句：

Hibernate: select student0_.id as col_0_0_ from t_student student0_ limit ?
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
沈凡
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
王志名
Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?
葉敦
.........

我們看到，當如果通過iterator()方法來獲得我們對象的時候，hibernate首先會發出1條sql去查詢出所有對象的 id 值，當我們如果需要查詢到某個對象的具體信息的時候，hibernate此時會根據查詢出來的 id 值再發sql語句去從資料庫中查詢對象的信息，這就是典型的 N+1 的問題。
那麼這種 N+1 問題我們如何解決呢，其實我們只需要使用 list() 方法來獲得對象即可。但是既然可以通過 list() 我們就不會出現 N+1的問題，那麼我們為什麼還要保留 iterator()這種形式呢？我們考慮這樣一種情況，如果我們需要在一個session當中要兩次查詢出很多對象，此時我們如果寫兩條 list()時，hibernate此時會發出兩條 sql 語句，而且這兩條語句是一樣的，但是我們如果第一條語句使用 list()，而第二條語句使用 iterator()的話，此時我們也會發兩條sql語句，但是第二條語句只會將查詢出對象的id，所以相對應取出所有的對象而已，顯然這樣可以節省內存，而如果再要獲取對象的時候，因為第一條語句已經將對象都查詢出來了，此時會將對象保存到session的一級緩存中去，所以再次查詢時，就會首先去緩存中查找，如果找到，則不發sql語句了。這里就牽涉到了接下來這個概念:hibernate的一級緩存。
二、一級緩存(session級別)
我們來看看hibernate提供的一級緩存：

/**
* 此時會發出一條sql，將所有學生全部查詢出來，並放到session的一級緩存當中
* 當再次查詢學生信息時，會首先去緩存中看是否存在，如果不存在，再去資料庫中查詢
* 這就是hibernate的一級緩存(session緩存)
*/
List<Student> stus = (List<Student>)session.createQuery("from Student")
.setFirstResult(0).setMaxResults(30).list();
Student stu = (Student)session.load(Student.class, 1);

我們來看看控制台輸出：
Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?

我們看到此時hibernate僅僅只會發出一條 sql 語句，因為第一行代碼就會將整個的對象查詢出來，放到session的一級緩存中去，當我如果需要再次查詢學生對象時，此時首先會去緩存中看是否存在該對象，如果存在，則直接從緩存中取出，就不會再發sql了，但是要注意一點：hibernate的一級緩存是session級別的，所以如果session關閉後，緩存就沒了，此時就會再次發sql去查資料庫。

『肆』 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也使用了緩存機制。在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的緩存機制請問下該怎麼回答

首先說下Hibernate緩存的作用（即為什麼要用緩存機制），然後再具體說說Hibernate中緩存的分類情況，最後可以舉個具體的例子。

『柒』 hibernate的緩存機制誰能詳細介紹一下

分一、二兩層緩存
所謂的緩存也就是在內存（虛存）中存有一份和數據源相同的數據。

一級緩存:由hibernate管理.雖然提供了幾個人為管理的api,但hibernate官方不建意人為參於.在增，刪、改的情況下，一級緩存內的數據會和數據源內的數據保持一致.具體怎麼保持一致看官方文檔
二級緩存:人為管理，可用於分布式架構中,緩存變化少，或是不變化的數據(比如城市信息)，可被多會話共享..

『捌』 什麼是hibernate緩存機制

這是面試中經常問到的一個問題，樓主可以按照我的思路回答，准你回答得很完美，首先說下Hibernate緩存的作用（即為什麼要用緩存機制），然後再具體說說Hibernate中緩存的分類情況，
最後可以舉個具體的例子。
Hibernate緩存的作用：
Hibernate是一個持久層框架，經常訪問物理資料庫，為了降低應用程序對物理數據源訪問的頻次，從而提高應用程序的運行性能。緩存內的數據是對物理數據源中的數據的復制，應用程序在運行時從緩存讀寫數據，在特定的時刻或事件會同步緩存和物理數據源的數據
Hibernate緩存分類：
Hibernate緩存包括兩大類：Hibernate一級緩存和Hibernate二級緩存
Hibernate一級緩存又稱為「Session的緩存」，它是內置的，不能被卸載（不能被卸載的意思就是這種緩存不具有可選性，必須有的功能，不可以取消session緩存）。由於Session對象的生命周期通常對應一個資料庫事務或者一個應用事務，因此它的緩存是事務范圍的緩存。第一級緩存是必需的，不允許而且事實上也無法卸除。在第一級緩存中，持久化類的每個實例都具有唯一的OID。
Hibernate二級緩存又稱為「SessionFactory的緩存」，由於SessionFactory對象的生命周期和應用程序的整個過程對應，因此Hibernate二級緩存是進程范圍或者集群范圍的緩存，有可能出現並發問題，因此需要採用適當的並發訪問策略，該策略為被緩存的數據提供了事務隔離級別。第二級緩存是可選的，是一個可配置的插件，在默認情況下，SessionFactory不會啟用這個插件。

什麼樣的數據適合存放到第二級緩存中？
1 很少被修改的數據
2 不是很重要的數據，允許出現偶爾並發的數據
3 不會被並發訪問的數據
4 常量數據
不適合存放到第二級緩存的數據？
1經常被修改的數據
2 .絕對不允許出現並發訪問的數據，如財務數據，絕對不允許出現並發
3 與其他應用共享的數據。

Hibernate查找對象如何應用緩存？
當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；查不到，如果配置了二級緩存，那麼從二級緩存中查；如果都查不到，再查詢資料庫，把結果按照ID放入到緩存
刪除、更新、增加數據的時候，同時更新緩存

Hibernate管理緩存實例
無論何時，我們在管理Hibernate緩存（Managing the caches）時，當你給save()、update()或saveOrUpdate()方法傳遞一個對象時，或使用load()、 get()、list()、iterate() 或scroll()方法獲得一個對象時, 該對象都將被加入到Session的內部緩存中。
當隨後flush()方法被調用時，對象的狀態會和資料庫取得同步。 如果你不希望此同步操作發生，或者你正處理大量對象、需要對有效管理內存時，你可以調用evict() 方法，從一級緩存中去掉這些對象及其集合。

這樣從頭到尾一說的話，很全很詳細，估計面試官對你的印象很好。不過也不要面面俱到，樓主可以挑一些自己懂得的內容說，不是很懂的內容可以省略，免得出漏子。

『玖』 hibernate緩存機制的二級緩存

Hibernate提供了兩級緩存，第一級是Session的緩存。由於Session對象的生命周期通常對應一個資料庫事務或者一個應用事務，因此它的緩存是事務范圍的緩存。第一級緩存是必需的，不允許而且事實上也無法卸除。在第一級緩存中，持久化類的每個實例都具有唯一的OID。
第二級緩存是一個可插拔的的緩存插件，它是由SessionFactory負責管理。由於SessionFactory對象的生命周期和應用程序的整個過程對應，因此第二級緩存是進程范圍或者集群范圍的緩存。這個緩存中存放的對象的鬆散數據。第二級對象有可能出現並發問題，因此需要採用適當的並發訪問策略，該策略為被緩存的數據提供了事務隔離級別。緩存適配器用於把具體的緩存實現軟體與Hibernate集成。第二級緩存是可選的，可以在每個類或每個集合的粒度上配置第二級緩存。 適合存放到第二級緩存中的數據
1 很少被修改的數據
2 不是很重要的數據，允許出現偶爾並發的數據
3 不會被並發訪問的數據
4 參考數據
不適合存放到第二級緩存的數據
1 經常被修改的數據
2 財務數據，絕對不允許出現並發
3 與其他應用共享的數據。 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都要從緩存中清空。