hibernate查詢緩存失效
1. hibernate 一級緩存session關閉後失效。二級緩存什麼時候失效
二級緩存是factory級別的，二級緩存被清除的時候會失效，例如：執行了executeUpdate等語句。
2. 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>
3. 怎樣解決hibernate中一級緩存導致數據不能刷新
Hibernate的一級緩存是由Session提供的，因此它只存在於Session的生命周期中，也就是當Session關閉的時候該Session所管理的一級緩存也會立即被清除。
Hibernate的一級緩存是Session所內置的，不能被卸載，也不能進行任何配置。
一級緩存採用的是key-value的Map方式來實現的，在緩存實體對象時，對象的主關鍵字ID是Map的key，實體對象就是對應的值。所以說，一級緩存是以實體對象為單位進行存儲的，在訪問的時候使用的是主關鍵字ID。
雖然，Hibernate對一級緩存使用的是自動維護的功能，沒有提供任何配置功能，但是可以通過Session中所提供的方法來對一級緩存的管理進行手工干預。Session中所提供的干預方法包括以下兩種。
evict() ：用於將某個對象從Session的一級緩存中清除。
clear() ：用於將一級緩存中的對象全部清除。
在進行大批量數據一次性更新的時候，會佔用非常多的內存來緩存被更新的對象。這時就應該階段性地調用clear()方法來清空一級緩存中的對象，控制一級緩存的大小，以避免產生內存溢出的情況。