Hibernate性能優化之EHCache緩存

時間 2019-11-20

標籤 hibernate 性能優化 ehcache 緩存欄目 Hibernate 简体版

原文原文鏈接

像Hibernate這種ORM框架，相較於JDBC操做，須要有更復雜的機制來實現映射、對象狀態管理等，所以在性能和效率上有必定的損耗。html

在保證避免映射產生低效的SQL操做外，緩存是提高Hibernate的關鍵之一。java

加入緩存能夠避免數據庫調用帶來的鏈接建立與銷燬、數據打包拆包、SQL執行、網絡傳輸，良好的緩存機制和合理的緩存模式能帶來性能的極大提高，EHCache就提供了這種良好的緩存機制。git

在考慮給系統加入緩存進行優化前，複用SessionFactory是Hibernate優化最優先、最基礎的性能優化方法，參考上一篇《Hibernate性能優化之SessionFactory重用》。github

Hibernate的緩存機制spring

緩存的級別通常分爲三種，每一種緩存的範圍更大：sql

事務級緩存：Hibernate中稱爲一級緩存，在一個Session中共享緩存對象；數據庫

應用級緩存：Hibernate中稱爲二級緩存，在一個SessionFactory中共享緩存對象，SessionFactory在整個應用範圍內重用；apache

分佈式緩存：部署爲單獨的實例，如Redis、Memcache等。json

Hibernate的按如下方式進行緩存：緩存

當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；

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

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

Hibernate默認不啓用二級緩存，EHCache是Hibernate中的二級緩存插件，使用Hibernate的系統能夠直接使用EHCache緩存。

爲何要直接使用EHCache

回頭來看那句話：良好的緩存機制和合理的緩存模式能帶來性能的極大提高。

Hibernate的緩存模式是什麼？

根據ID來緩存對象，也就是Session的get、load操做時。

這種緩存模式的弊端有兩點：

一、應用場景太單一，系統中大量的列表式查詢緩存起不到做用；

二、一些系統中經過ThreadLocal在線程中重用Session，每一個線程可能須要大量處理不用的業務邏輯，緩存命中率很低；若是不重用Session，通常的場景緩存命中率更低。

既然EHCache已經提供了良好的緩存機制，結合本身系統的業務來優化緩存模式纔是最佳的。

如何使用EHCache

EHCache是Hibernate中的二級緩存插件，使用Hibernate的系統能夠直接使用EHCache緩存，不須要再添加其餘jar包。

新建EHCache配置文件，具體的配置含義能夠查手冊：

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
   xsi:noNamespaceSchemaLocation="ehcache.xsd">  
  <diskStore path="java.io.tmpdir"/>  
  <defaultCache  
    maxElementsInMemory="10000"  
    maxElementsOnDisk="0"  
    eternal="true"  
    overflowToDisk="true"  
    diskPersistent="false"  
    timeToIdleSeconds="0"  
    timeToLiveSeconds="0"  
    diskSpoolBufferSizeMB="50"  
    diskExpiryThreadIntervalSeconds="120"  
    memoryStoreEvictionPolicy="LFU"  
    />  
  <cache name="restCache"  
    maxElementsInMemory="100"  
    maxElementsOnDisk="0"  
    eternal="false"  
    overflowToDisk="false"  
    diskPersistent="false"  
    timeToIdleSeconds="119"  
    timeToLiveSeconds="119"  
    diskSpoolBufferSizeMB="50"  
    diskExpiryThreadIntervalSeconds="120"  
    memoryStoreEvictionPolicy="FIFO"  
    />  
</ehcache>

EHCache的一個優勢是線程安全的，適合多線程的使用場景，能簡化開發人員的使用。

所以我寫了一個單例模式，避免每次在方法裏寫getCache，這個類也涵蓋了EHCache的基本使用：

public class EHCacheFactory {
    
    private final CacheManager manager;
    private final Cache cache;
    
    private EHCacheFactory() {
        manager = CacheManager.create(getClass().getResource("/ehcache.xml"));
        cache = manager.getCache("restCache");
    }
    
    public Element getCache(String strKey) {
        return EHCacheFactory.getInstance().getCache().get(strKey);
    }
    
    public void setCache(String strKey, String strVal) {
        EHCacheFactory.getInstance().getCache().put(new Element(strKey, strVal));
    }
    
    public Cache getCache() {
        return cache;
    }
    
    private static class SingletonHolder {

        private final static EHCacheFactory INSTANCE = new EHCacheFactory();
    }

    public static EHCacheFactory getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

個人系統是JAVA REST，在須要緩衝的REST接口中加入了EHCache緩存，經過URL參數做爲緩存鍵值，REST接口返回的json數據做爲緩存值，這種緩存模式很是適合REST。

使用ab進行了簡單的性能測試：

在一個簡答查詢接口中，性能提高一倍；

在一個略複雜接口中，執行四、5個查詢，加入緩存後性能提高20倍。

介紹在Hibernate中使用查詢緩存、一級緩存、二級緩存，

整合Spring在HibernateTemplate中使用查詢緩存。

EhCache是Hibernate的二級緩存技術之一，能夠把查詢出來的數據存儲在內存或者磁盤，節省下次一樣查詢語句再次查詢數據庫，大幅減輕數據庫壓力；

EhCache的使用注意點

當用Hibernate的方式修改表數據(save,update,delete等等)，這時EhCache會自動把緩存中關於此表的全部緩存所有刪除掉(這樣能達到同步)。但對於數據常常修改的表來講，可能就失去緩存的意義了(不能減輕數據庫壓力)；

在比較少更新表數據的狀況下，EhCache通常要使用在比較少執行write操做的表(包括update,insert,delete等)[Hibernate的二級緩存也都是這樣]；對併發要求不是很嚴格的狀況下，兩臺機子中的緩存是不能實時同步的；

首先要在hibernate.cfg.xml配置文件中添加配置，在hibernate.cfg.xml中的mapping標籤上面加如下內容：

<!--  Hibernate 3.3 and higher -->  
<!--   
<property name="hibernate.cache.region.factory_class">net.sf.ehcache.hibernate.EhCacheRegionFactory</property>
<property name="hibernate.cache.region.factory_class">net.sf.ehcache.hibernate.SingletonEhCacheRegionFactory</property>
-->  
<!-- hibernate3.0-3.2 cache config-->  
<!--    
<property name="hibernate.cache.region.factory_class">net.sf.ehcache.hibernate.EhCacheProvider</property>  
-->  
<property name="hibernate.cache.provider_class">net.sf.ehcache.hibernate.SingletonEhCacheProvider</property>  
           
<!-- Enable Second-Level Cache and Query Cache Settings -->  
<property name="hibernate.cache.use_second_level_cache">true</property>  
<property name="hibernate.cache.use_query_cache">true</property>

若是你是整合在spring配置文件中，那麼你得配置你的applicationContext.xml中相關SessionFactory的配置

<prop key="hibernate.cache.use_query_cache">true</prop>
<prop key="hibernate.cache.use_second_level_cache">true</prop>
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>

而後在hibernate.cfg.xml配置文件中加入使用緩存的屬性

<!-- class-cache config -->  
<class-cache class="com.hoo.hibernate.entity.User" usage="read-write" />

固然你也能夠在User.hbm.xml映射文件須要Cache的配置class節點下，加入相似以下格式信息：

<class name="com.hoo.hibernate.entity.User" table="USER" lazy="false">
<cache usage="transactional|read-write|nonstrict-read-write|read-only" />

注意：cache節點元素應緊跟class元素

關於選擇緩存策略依據：

ehcache不支持transactional，其餘三種能夠支持。

read- only：無需修改，能夠對其進行只讀緩存，注意：在此策略下，若是直接修改數據庫，即便可以看到前臺顯示效果，可是將對象修改至cache中會報error，cache不會發生做用。另：刪除記錄會報錯，由於不能在read-only模式的對象從cache中刪除。

read-write：須要更新數據，那麼使用讀/寫緩存比較合適，前提：數據庫不能夠爲serializable transaction isolation level（序列化事務隔離級別）

nonstrict-read-write：只偶爾須要更新數據（也就是說，兩個事務同時更新同一記錄的狀況很不常見），也不須要十分嚴格的事務隔離，那麼比較適合使用非嚴格讀/寫緩存策略。

若是你使用的註解方式，沒有User.hbm.xml，那麼你也能夠用註解方式配置緩存

 
   @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)   
public class User implements Serializable {
} 
  

在Dao層使用cache，代碼以下

Session s = HibernateSessionFactory.getSession();
Criteria c = s.createCriteria(User.class);
c.setCacheable(true);//這句必需要有
System.out.println("第一次讀取");
List<User> users = c.list();
System.out.println(users.size());
HibernateSessionFactory.closeSession();
 
s = HibernateSessionFactory.getSession();
c = s.createCriteria(User.class);
c.setCacheable(true);//這句必需要有
System.out.println("第二次讀取");
users = c.list();
System.out.println(users.size());
HibernateSessionFactory.closeSession();

你會發現第二次查詢沒有打印sql語句，而是直接使用緩存中的對象。

若是你的Hibernate和Spring整合在一塊兒，那麼你能夠用HibernateTemplate來設置cache

getHibernateTemplate().setCacheQueries(true);
return getHibernateTemplate().find("from User");

當你整合Spring時，若是你的HibernateTemplate模板配置在Spring的Ioc容器中，那麼你能夠這樣啓用query cache

<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
    <property name="sessionFactory">
       <ref bean="sessionFactory" />
    </property>
    <property name="cacheQueries">
       <value>true</value>
    </property>
</bean>

此後，你在dao模塊中注入sessionFactory的地方都注入hibernateTemplate便可。

以上講到的都是Spring和Hibernate的配置，下面主要結合上面使用的ehcache，來完成ehcache.xml的配置。若是你沒有配置ehcache，默認狀況下使用defaultCache的配置。

 
   <cache name="com.hoo.hibernate.entity.User" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" />
<!--
hbm文件查找cache方法名的策略：若是不指定hbm文件中的region="ehcache.xml中的name的屬性值"，則使用name名爲com.hoo.hibernate.entity.User的cache，若是不存在與類名匹配的cache名稱，則用 defaultCache。
若是User包含set集合，則須要另行指定其cache
例如User包含citySet集合，則須要
添加以下配置到ehcache.xml中
-->
<cache name="com.hoo.hibernate.entity.citySet"
maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300"
timeToLiveSeconds="600" overflowToDisk="true" />  
  

若是你使用了Hibernate的查詢緩存，須要在ehcache.xml中加入下面的配置

<cache name="org.hibernate.cache.UpdateTimestampsCache"
    maxElementsInMemory="5000" 
    eternal="true" 
    overflowToDisk="true" />
<cache name="org.hibernate.cache.StandardQueryCache"
    maxElementsInMemory="10000" 
    eternal="false" 
    timeToLiveSeconds="120"
    overflowToDisk="true" />

調試時候使用log4j的log4j.logger.org.hibernate.cache=debug，更方便看到ehcache的操做過程，主要用於調試過程,實際應用發佈時候，請註釋掉，以避免影響性能。

使用ehcache，打印sql語句是正常的，由於query cache設置爲true將會建立兩個緩存區域：一個用於保存查詢結果集 (org.hibernate.cache.StandardQueryCache)；另外一個則用於保存最近查詢的一系列表的時間戳(org.hibernate.cache.UpdateTimestampsCache)。請注意：在查詢緩存中，它並不緩存結果集中所包含的實體的確切狀態；它只緩存這些實體的標識符屬性的值、以及各值類型的結果。須要將打印sql語句與最近的cache內容相比較，將不一樣之處修改到cache中，因此查詢緩存一般會和二級緩存一塊兒使用。

二級緩存是屬於SessionFactory級別的緩存機制，是屬於進程範圍的緩存。一級緩存是Session級別的緩存，是屬於事務範圍的緩存，由Hibernate管理，通常無需進行干預。

Hibernate支持如下的第三方的緩存框架：

Cache	Interface	Supported strategies
HashTable (testing only)		read-only nontrict read-write read-write
EHCache		read-only nontrict read-write read-write
OSCache		read-only nontrict read-write read-write
SwarmCache		read-only nontrict read-write
JBoss Cache 1.x		read-only transactional
JBoss Cache 2.x		read-only transactional

二、下載第三方ehcache.jar

ehcache.jar包的話，有兩種，一種是org.ehcache，另外一種是net.sf.ehache。Hibernate集成的是net.sf.ehcache！！因此應該下載net.sf.ehcache。若是使用org.ehcache的jar包，hibernate是不支持的！！

下載下來的jar包，須要放到項目當中，在本案例，是放到SSHWebProject項目的WebRoot/WEB-INF/lib目錄下，須要注意的是，ehcache.jar包依賴commons-logging.jar，你還得看看你項目中有沒有commons-logging.jar！！

三、開啓hibernate的二級緩存

想是否使用hibernate.cfg.xml配置文件，會致使配置使用二級緩存的方式不同，通常是因爲項目集成了Spring框架，因此配置二級緩存的話，

就分如下兩種狀況：

1）項目有hibernate.cfg.xml

1-1）開啓Hibernate緩存二級緩存功能

修改hibernate.cfg.xml，添加如下內容

   <!-- 開啓二級緩存，使用EhCache緩存 -->  
<prop key="hibernate.cache.use_second_level_cache">true</prop>  
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
          1-2）配置哪些實體類的對象須要存放到二級緩存，有兩種方式

                    本案例中，以edu.po.Users用戶對象爲例子，對應的實體映射文件爲Users.hbm.xml。

                   方式一，在hibernate.cfg.xml文件中配置

<!-- 要使用二級緩存的對象配置 -->  
   <class-cache usage="read-write" class="edu.po.Users"/>    
<!-- 緩存集合對象的例子 -->  
<!-- <collection-cache usage="read-write" collection="cn.itcast.domain.Customer.orders"/> -->

方式二，在hbm文件（實體映射文件）中配置

Users.hbm.xml，添加如下內容：

<cache usage="read-write"/>

2）集成了Spring框架以後，沒有hibenate.cfg.mlx文件

1-1）開啓Hibernate緩存二級緩存功能

修改applicationContext.xml文件，在sessionFactory Bean中添加如下hibernateProperties，以下：

<bean id="sessionFactory"  
    class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
    ......  
    <property name="hibernateProperties">  
        <props>  
           ......  
           <!-- 開啓二級緩存，使用EhCache緩存 -->  
           <prop key="hibernate.cache.use_second_level_cache">true</prop>  
           <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
           ......  
        </props>  
    </property>  
    <property name="mappingResources">  
        <list>  
           <value>edu/po/Users.hbm.xml</value>  
           <value>edu/po/TLog.hbm.xml</value>  
        </list>  
    </property>  
</bean>

1-2）配置哪些實體類的對象須要存放到二級緩存

本案例中，以edu.po.Users用戶對象爲例子，對應的實體映射文件爲Users.hbm.xml。

在hbm文件（實體映射文件）中配置

Users.hbm.xml，添加如下內容：

<cache usage="read-write"/>

四、配置ehcache.xml文件

將ehcache.jar包中的ehcache-failsafe.xml 更名爲 ehcache.xml 放入 src，由於hibernate默認找classpath*:ehcache.xml

本案例，對<diskStore>和<defaultCache>進行修改，以下

<diskStore path="d:/EhCacheData"/>

<!--   
   maxElementsInMemory: 內存中最大對象數量 ，超過數量，數據會被緩存到硬盤  
   eternal：緩存的對象是否有有效期（便是否永久存在）。若是爲true，timeouts屬性被忽略  
   timeToIdleSeconds：緩存的對象在過時前的空閒時間，單位秒  
   timeToLiveSeconds：存活時間，對象不論是否使用，到了時間回收，單位秒  
   overflowToDisk：當內存中緩存對象數量達到 maxElementsInMemory 限制時，是否能夠寫到硬盤  
   maxElementsOnDisk：硬盤緩存最大對象數量  
   diskPersistent：在java虛擬機（JVM）重啓或停掉的時候，是否持久化磁盤緩存，默認是false  
   diskExpiryThreadIntervalSeconds：清除磁盤緩存中過時對象的監聽線程的運行間隔，默認是120秒  
   memoryStoreEvictionPolicy：當內存緩存的對象數量達到最大，有新的對象要加入的時候，  
                                                                移除緩存中對象的策略。默認是LRU，可選的有LFU和FIFO  
-->  
<defaultCache  
        maxElementsInMemory="10000"   
        eternal="false"  
        timeToIdleSeconds="120"  
        timeToLiveSeconds="120"  
        overflowToDisk="true"  
        diskPersistent="true"  
        diskExpiryThreadIntervalSeconds="120"  
        memoryStoreEvictionPolicy="LRU"  
        />

五、demo

SpringBeanUtils.java：

package utils;  
  
import org.apache.log4j.Logger;  
import org.hibernate.SessionFactory;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.FileSystemXmlApplicationContext;  
  
/** 
 * Title: SpringBeanUtils.java 
 * Description: 獲取Spring的Bean實例對象的工具類 
 * @author yh.zeng 
 * @date 2017-6-27 
 */  
public class SpringBeanUtils {  
      
    private static Logger logger = Logger.getLogger(SpringBeanUtils.class);  
      
    static String filePath ="WebRoot/WEB-INF/applicationContext.xml";  
    static  ApplicationContext CONTEXT ;  
    static{  
        try{  
            CONTEXT = new FileSystemXmlApplicationContext(filePath);  
        }catch(Exception e){  
            logger.error(StringUtils.getExceptionMessage(e));  
        }  
    }  
      
      
    /** 
     * 獲取Bean 
     * @param uniqueIdentifier Bean的惟一標識，能夠是ID也能夠是name 
     * @return 
     */  
    public static Object getBean(String uniqueIdentifier){  
        return CONTEXT.getBean(uniqueIdentifier);  
    }  
      
    /** 
     * 獲取SessionFacotry對象 
     * @param uniqueIdentifier  SessionFactory Bean的惟一標識，能夠是ID也能夠是name 
     * @return 
     */  
    public static SessionFactory getSessionFactory(String uniqueIdentifier){  
        return (SessionFactory) CONTEXT.getBean(uniqueIdentifier);  
    }  
  
    public static String getFilePath() {  
        return filePath;  
    }  
  
    public static void setFilePath(String filePath) {  
        SpringBeanUtils.filePath = filePath;  
        CONTEXT = new FileSystemXmlApplicationContext(filePath);  
    }  
      
}

HibernateEhCacheTest.java：

注意：查詢緩存和查看Cache（緩存）統計信息的功能，須要作另外配置，見博客Hibernate開啓查詢緩存、Hibernate開啓收集緩存統計信息

package edu.test;  
  
import java.sql.SQLException;  
import org.hibernate.HibernateException;  
import org.hibernate.Query;  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.stat.EntityStatistics;  
import org.hibernate.stat.Statistics;  
import org.springframework.orm.hibernate3.HibernateCallback;  
import org.springframework.orm.hibernate3.HibernateTemplate;  
import utils.SpringBeanUtils;  
import edu.po.Users;  
  
/** 
 * Title: HibernateEhCacheTest.java 
 * Description: Hibernate二級緩存測試 
 * @author yh.zeng 
 * @date 2017-7-4 
 */  
public class HibernateEhCacheTest {  
  
    static SessionFactory  sessionFactory = SpringBeanUtils.getSessionFactory("sessionFactory");  
      
    public static void main(String args[]) {  
          
        //Session.get()方法支持二級緩存  
        System.out.println("###############session.get()###############");  
        Session session1 = sessionFactory.openSession();  
        session1.beginTransaction();  
        Users user1 = (Users)session1.get(Users.class, 6);  
        System.out.println("用戶名：" + user1.getUsername());  
        session1.getTransaction().commit();  
        session1.close();  
  
        Session session2 = sessionFactory.openSession();  
        session2.beginTransaction();  
        Users user2 = (Users)session2.get(Users.class, 6);  
        System.out.println("用戶名：" + user2.getUsername());  
        session2.getTransaction().commit();  
        session2.close();  
          
        //Query.list()方法支持查詢緩存  
        System.out.println("###############Query.list()###############");  
        Session session3 = sessionFactory.openSession();  
        session3.beginTransaction();  
        Query query = session3.createQuery("from Users where id = :id");  
        query.setParameter("id", 6);  
        query.setCacheable(true); //啓用查詢緩存  
        Users user3 = (Users)query.list().get(0);  
        System.out.println("用戶名：" + user3.getUsername());  
        session3.getTransaction().commit();  
        session3.close();  
          
          
        Session session4 = sessionFactory.openSession();  
        session4.beginTransaction();  
        Query query2 = session4.createQuery("from Users where id = :id");  
        query2.setParameter("id", 6);  
        query2.setCacheable(true); //啓用查詢緩存  
        Users user4 = (Users)query2.list().get(0);  
        System.out.println("用戶名：" + user4.getUsername());  
        session4.getTransaction().commit();  
        session4.close();  
          
        //Query.iterate()方法不支持查詢緩存  
        System.out.println("###############Query.iterate()###############");  
        Session session5 = sessionFactory.openSession();  
        session5.beginTransaction();  
        Query query3 = session5.createQuery("from Users where id = :id");  
        query3.setParameter("id", 6);  
        query3.setCacheable(true); //啓用查詢緩存  
        Users user5 = (Users)query3.iterate().next();  
        System.out.println("用戶名：" + user5.getUsername());  
        session5.getTransaction().commit();  
        session5.close();  
          
        Session session6 = sessionFactory.openSession();  
        session6.beginTransaction();  
        Query query4 = session6.createQuery("from Users where id = :id");  
        query4.setParameter("id", 6);  
        query4.setCacheable(true); //啓用查詢緩存  
        Users user6 = (Users)query4.iterate().next();  
        System.out.println("用戶名：" + user6.getUsername());  
        session6.getTransaction().commit();  
        session6.close();  
          
        //Session.load()方法支持二級緩存  
        System.out.println("###############Session.load()###############");  
        Session session7 = sessionFactory.openSession();  
        session7.beginTransaction();  
        Users user7 = (Users)session7.load(Users.class, 6);  
        System.out.println("用戶名：" + user7.getUsername());  
        session7.getTransaction().commit();  
          
        Session session8 = sessionFactory.openSession();  
        session8.beginTransaction();  
        Users user8 = (Users)session8.load(Users.class, 6);  
        System.out.println("用戶名：" + user8.getUsername());  
        session8.getTransaction().commit();  
          
        //HibernateTemplate.find支持查詢緩存  
        System.out.println("###############HibernateTemplate.find()###############");  
        HibernateTemplate hibernateTemplate = new HibernateTemplate(sessionFactory);  
        hibernateTemplate.setCacheQueries(true); //開啓查詢緩存  
        Users user9 = (Users)hibernateTemplate.find("from Users where id = ?",6).get(0);  
        System.out.println("用戶名：" + user9.getUsername());  
          
        HibernateTemplate hibernateTemplate2 = new HibernateTemplate(sessionFactory);  
        hibernateTemplate2.setCacheQueries(true); //開啓查詢緩存  
        Users user10 = (Users)hibernateTemplate2.find("from Users where id = ?",6).get(0);  
        System.out.println("用戶名：" + user10.getUsername());  
          
        //HibernateTemplate.execute支持查詢緩存  
        System.out.println("###############HibernateTemplate.execute()###############");  
        HibernateTemplate hibernateTemplate3 = new HibernateTemplate(sessionFactory);  
        hibernateTemplate3.setCacheQueries(true); //開啓查詢緩存  
        Users user11 = hibernateTemplate3.execute(new HibernateCallback<Users>() {  
            @Override  
            public Users doInHibernate(Session session) throws HibernateException,  
                    SQLException {  
                // TODO Auto-generated method stub  
                Query query = session.createQuery("from Users where id = :id");  
                query.setParameter("id", 6);  
                return (Users)query.list().get(0);  
            }  
        });  
        System.out.println("用戶名：" + user11.getUsername());  
          
        HibernateTemplate hibernateTemplate4 = new HibernateTemplate(sessionFactory);  
        hibernateTemplate4.setCacheQueries(true); //開啓查詢緩存  
        Users user12 = hibernateTemplate4.execute(new HibernateCallback<Users>() {  
            @Override  
            public Users doInHibernate(Session session) throws HibernateException,  
                    SQLException {  
                // TODO Auto-generated method stub  
                Query query = session.createQuery("from Users where id = :id");  
                query.setParameter("id", 6);  
                return (Users)query.list().get(0);  
            }  
        });  
        System.out.println("用戶名：" + user12.getUsername());  
          
        //Cache統計統計信息  
        Statistics statistics= sessionFactory.getStatistics();  
        System.out.println(statistics);  
        System.out.println("放入"+statistics.getSecondLevelCachePutCount());  
        System.out.println("命中"+statistics.getSecondLevelCacheHitCount());  
        System.out.println("錯過"+statistics.getSecondLevelCacheMissCount());  
        //詳細的Cache統計信息  
        for (int i = 0; i < statistics.getEntityNames().length; i++) {  
            String entityName = statistics.getEntityNames()[i];  
            EntityStatistics entityStatistics = statistics.getEntityStatistics(entityName);  
            StringBuilder cacheOperator = new StringBuilder();  
            cacheOperator.append("CategoryName：" ).append(entityStatistics.getCategoryName())  
                         .append("，DeleteCount：").append(entityStatistics.getDeleteCount())  
                         .append("，FetchCount：").append(entityStatistics.getFetchCount())  
                         .append("，InsertCount：").append(entityStatistics.getInsertCount())  
                         .append("，LoadCount：").append(entityStatistics.getLoadCount())                        
                         .append("，OptimisticFailureCount：").append(entityStatistics.getOptimisticFailureCount())     
                         .append("，UpdateCount：").append(entityStatistics.getUpdateCount());                           
            System.out.println(cacheOperator.toString());  
        }  
    }  
}