SSH2搭建框架如何配置hibernate 缓存

莫小柒

1、首先设置EhCache，建立配置文件ehcache.xml，默认的位置在class-path，可以放到你的src目录下：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
4 P" n3 ]1 r& r5 f　<diskStore path="java.io.tmpdir"/>
　　<defaultCache
　　　maxElementsInMemory="10000" <!-- 缓存最大数目 -->
! F3 M% X6 l! \- d7 r) q; G　　　eternal="false" <!-- 缓存是否持久 -->

　　　overflowToDisk="true" <!-- 是否保存到磁盘，当系统当机时-->

　　　timeToIdleSeconds="300" <!-- 当缓存闲置n秒后销毁 -->
6 D/ e% ]' p+ J5 F2 o　　　timeToLiveSeconds="180" <!-- 当缓存存活n秒后销毁-->
　　　diskPersistent="false"
% ?- _- k& M) ]! i) {  n4 R% `　　　diskExpiryThreadIntervalSeconds= "120"/>
</ehcache>

　　2、在hibernate配置文件中设置：

<!-- 设置Hibernate的缓存接口类，这个类在Hibernate包中 -->
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
, |9 Y! B3 k7 e& [. z! g　<!-- 是否使用查询缓存 -->

　<property name="hibernate.cache.use_query_cache">true</property>
0 P" K# ?, ?5 C. O/ o; J　　如果使用spring调用Hibernate的sessionFactory的话，这样设置：
　　<!--HibernateSession工厂管理 -->

　　　<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
; z7 v: \" ~/ [) Q* r! a　　　<property name="dataSource">
　　　　<ref bean="datasource" />
& I. x$ {, s, z/ U; G% }　　　</property>
: @8 h. U! s" c0 B  \　　　<property name="hibernateProperties">
　　　<props>
　　　　<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
: Q" J: |; y" a- e, K' t) }　　　  <prop key="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</prop>
2 P7 b, w* g  Z0 r; _2 t' u　　　　<prop key="hibernate.show_sql">true</prop>
) h- x3 f2 ], G; ~0 q8 y　　　　<prop key="hibernate.cache.use_query_cache">true</prop>
　　　　<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
! j% ^6 V+ X! E( w0 F' |　　　</props>
) l9 i3 J5 ]  Z7 X# B　</property>
0 _: d0 I- h9 N& m0 ^- ~　<property name="mappingDirectoryLocations">
　　<list>
　　　<value>/WEB-INF/classes/cn/rmic/manager/hibernate/</value>
　　</list>
　</property>
2 e. [6 F8 r1 k; S& A</bean>

　　说明一下：如果不设置“查询缓存”，那么hibernate只会缓存使用load()方法获得的单个持久化对象，如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话，就需要设置hibernate.cache.use_query_cache true 才行

　　3、在Hbm文件中添加<cache usage="read-only"/>

　　4、如果需要“查询缓存”，还需要在使用Query或Criteria()时设置其setCacheable(true);属性

　　5、实践出真知，给一段测试程序，如果成功的话第二次查询时不会读取数据库

package cn.rmic.hibernatesample;

import java.util.List;

import org.hibernate.CacheMode;
import org.hibernate.Criteria;
; s$ W9 k: y& I5 H% N" i$ Oimport org.hibernate.Query;
import org.hibernate.Session;

import cn.rmic.hibernatesample.hibernate.HibernateSessionFactory;
0 I% g3 o& E3 _8 m/ B2 y2 ?% Kimport cn.rmic.manager.po.Resources;

public class testCacheSelectList ...{

　public static void main(String[] args) ...{
4 M. l' O- {5 m　　Session s=HibernateSessionFactory.getSession();
　　Criteria c=s.createCriteria(Resources.class);
: u/ y' a" C; }+ U! |2 @7 S　　c.setCacheable(true);
　　List l=c.list();

　　Resources resources=(Resources)l.get(0);
5 P. K& @% C+ P4 O" L3 v　　System.out.println("-1-"+resources.getName());
: t, R- X" l5 t7 |: F$ q" ^' S　　HibernateSessionFactory.closeSession();

4 f. R7 {$ z" K$ s5 N7 J0 }( H　　try ...{
　　　Thread.sleep(5000);
　　} catch (InterruptedException e) ...{
- N- k5 A6 S( ?　　　// TODO Auto-generated catch block
# J( @  z* x" i6 b4 ^; p　　　e.printStackTrace();
0 `  u  e% a- E4 a' h: T　　}
　　s=HibernateSessionFactory.getSession();
& O. ]7 u, L$ `0 Q　　c=s.createCriteria(Resources.class);
　　c.setCacheable(true);
　　l=c.list();
　　resources=(Resources)l.get(0);
　　System.out.println("-2-"+resources.getName());
　　HibernateSessionFactory.closeSession();
- I  Z$ n: W: r# a* I- d　}
}

5 E7 u  J3 W6 `2 j( X+ x$ R

1. 在Hibernate配置文件中设置：
7 V0 K2 B" ^( e1 ?, Y: W   

<!-- Hibernate SessionFactory -->
. B% \9 x" x0 L2 t3 m1 B" G    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
% ~. L. ^2 u; N) b# N1 g        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
        <list>
" U( H8 P7 U+ a3 ?  w9 B( C& k1 u            <value>com/ouou/model/Videos.hbm.xml</value>  
         </list>
; D! X$ F( [1 {% z( o         </property>
        <property name="hibernateProperties">
            <props>
1 [3 B3 M7 e5 Q                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
- y; W+ F5 f( c$ Y4 `% W                <prop key="hibernate.current_session_context_class">thread</prop>
) ]" Q( y+ S1 I" y                <prop key="hibernate.cglib.use_reflection_optimizer">false</prop>
                <prop key="hibernate.query.substitutions">true 'Y', false 'N'</prop>
                <!--add ehcache-->
' M$ P9 n6 E. s- p+ V2 X9 d& d9 t                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
                <prop key="hibernate.cache.use_query_cache">false</prop><!-- 是否使用查询缓存 -->
( m% e& G* T2 N8 q                <!--
                <prop key="hibernate.cache.provider_configuration_file_resource_path">/ehcache.xml</prop>
* X7 e* J; I6 Q" a! `; G                <prop key="hibernate.show_sql">true</prop>
                -->
                <!--<prop key="hibernate.transaction.auto_close_session">true</prop>-->
; c( a/ g1 u- z) M' T5 R! m                <prop key="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</prop>
                <!-- Create/update the database tables automatically when the JVM starts up
9 O) y3 R6 R' K* E                 <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                <!-- Turn batching off for better error messages under PostgreSQL -->
0 A1 M( _1 r% w- P4 C2 \: X9 v                <prop key="hibernate.jdbc.batch_size">25</prop>
' g/ U1 Q+ ]: W                <!--
                <prop key="hibernate.connection.pool_size">10</prop>
                -->
) u4 _8 e" N3 A" t, J9 e/ g            </props>
* ^3 @3 U: M3 F        </property>
8 T* @9 g8 R6 C) W0 `  Y    </bean>

    如果不设置“查询缓存”，那么hibernate只会缓存使用load()方法获得的单个持久化对象，如果想缓存使用findall()、 list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话，就需要设置hibernate.cache.use_query_cache true 才行

2.首先设置EhCache，建立配置文件ehcache.xml，默认的位置在class-path，可以放到你的src目录下：

& {" [- f  |, A  r4 m! \4 o* y <ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

     If the path is a Java System Property it is replaced by
( A, [& _+ W" |: s* L& L     its value in the running VM.
: b: t6 @4 |" g1 J5 p8 a: J     The following properties are translated:
8 u' C. Q) ]5 L     user.home - User's home directory
     user.dir - User's current working directory
2 ]0 S9 v# C6 k0 A) X     java.io.tmpdir - Default temp file path -->
: X) V8 \' G9 Z  t4 n. n0 B     <!--<diskStore path="java.io.tmpdir"/>-->
     <diskStore path="/data/ehcache"/>

    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required:

        maxElementsInMemory            - Sets the maximum number of objects that will be created in memory
! ~( }1 A" D4 u" j/ J/ s        eternal                                     - Sets whether elements are eternal. If eternal,  timeouts are
                                                            ignored and the element is never expired.
        overflowToDisk                      - Sets whether elements can overflow to disk when the in-memory cache
                                                        has reached the maxInMemory limit.

        The following attributes are optional:
        timeToIdleSeconds            - Sets the time to idle for an element before it expires.
& a( y; |+ P- P! x4 L, r0 K                                                        i.e. The maximum amount of time between accesses before an
                                                        element expires Is only used if the element is not eternal.
- U; d# E6 X, E  _6 F                                                        Optional attribute. A value of 0 means that an Element can idle
( M0 m; K5 z- w, a6 p+ F" R* u                                                        for infinity.The default value is 0.
8 l9 W$ v  `) w/ X8 K. i/ v& H        timeToLiveSeconds              - Sets the time to live for an element before it expires.
                                                         i.e. The maximum time between creation time and when an element
" u  m$ L6 o3 @+ }- O                                                         expires.  Is only used if the element is not eternal.
                                                         Optional attribute. A value of 0 means that and Element can live
                                                         for infinity.
                                                        The default value is 0.
        diskPersistent                           - Whether the disk store persists between restarts of the Virtual
                                                             Machine.
                                                         The default value is false.
. o6 y3 U# M. Z3 q* B  m1 u5 f        diskExpiryThreadIntervalSeconds   - The number of seconds between runs of the disk expiry thread.
                                                         The default value  is 120 seconds.
, [9 _* i* D0 N/ z1 y- N        -->

    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
7 r0 p) B* K3 l        overflowToDisk="true"
3 U* i7 a1 M$ Y$ P$ @' P  ?3 Y        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        diskPersistent="false"
( e$ S8 P2 C0 G4 J  ~: X  n+ i        diskExpiryThreadIntervalSeconds="120"/>
, |; ~) L0 K8 b! A' \    <cache name="org.hibernate.cache.UpdateTimestampsCache" maxElementsInMemory="5000"
$ k, P8 P0 b& j! `     eternal="true" overflowToDisk="true"/>
    <cache name="org.hibernate.cache.StandardQueryCache" maxElementsInMemory="5" eternal="false"
    timeToLiveSeconds="120" overflowToDisk="true"/>
3 @5 p) G) d0 Z. V# p    <cache name="userCache" maxElementsInMemory="100000" eternal="false" timeToIdleSeconds=
  P% U# X7 K' X( Z/ P        "600"    timeToLiveSeconds="600" overflowToDisk="false" diskPersistent="false"/>
    <cache name="com.ouou.webapp.util.OuouMethodIntecepter" maxElementsInMemory="100000"
1 k) p7 d- N2 d7 j' e    eternal="false" timeToIdleSeconds="600" timeToLiveSeconds="600" overflowToDisk="false"
    diskPersistent="false"/>
    <cache name="bbcode" maxElementsInMemory="100000" eternal="false" timeToIdleSeconds="600"
    timeToLiveSeconds="600"
7 `) c1 l. w7 [  N3 k, E( r    overflowToDisk="false" diskPersistent="false"/>
    <cache name="com.ouou.model.Videos" maxElementsInMemory="10000"  eternal="false"
+ e# y  Z! m$ T5 Y+ q8 \    overflowToDisk="false" timeToIdleSeconds="120" timeToLiveSeconds="120" diskPersistent="false"/>
    <cache name="com.ouou.model.Tags" maxElementsInMemory="10000"  eternal="false"
    overflowToDisk="false" timeToIdleSeconds="120" timeToLiveSeconds="120" diskPersistent="false"/>
3 m4 r) M$ H6 U1 d8 J</ehcache>

以com.ouou.model.Videos为例子
在Videos.hbm.xml中配置：
0 G8 }* I. [, p3 ]/ i! L2 r; ~<class name="Videos" table="TEST" lazy="false">
% l" Y, t* U  k' j+ b* D  <cache usage="read-write" region="ehcache.xml中的name的属性值"/>注意：这一句需要紧跟在class标签下面，其他位置无效。
hbm文件查找cache方法名的策略：如果不指定hbm文件中的region="ehcache.xml中的name的属性值"，则使用name名为com.ouou.model.Videos的cache，
% c  U) T9 V4 I# ^, {( t如果不存在与类名匹配的cache名称，则用defaultCache。
) o8 {+ S; C! a" W$ ^" k如果Videos包含set集合，则需要另行指定其cache
例如Videos包含Tags集合，则需要
添加如下配置到ehcache.xml中
<cache name="com.ouou.model.Tags"
        maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120"
        timeToLiveSeconds="120" overflowToDisk="false" />
另，针对查询缓存的配置如下：
<cache name="org.hibernate.cache.UpdateTimestampsCache"
        maxElementsInMemory="5000"
, N  W1 \2 l% l) C; h' U        eternal="true"
1 G% e" V# q) V4 |. L! z+ s/ R8 w; s        overflowToDisk="true"/>
' b/ v% E" @/ ~' j6 i8 i<cache name="org.hibernate.cache.StandardQueryCache"
- \- f) I0 B# Z4 N1 O3 F/ z/ T        maxElementsInMemory="10000"
        eternal="false"
        timeToLiveSeconds="120"
: q$ U1 y+ g% }6 j2 ]" H- a3 n        overflowToDisk="true"/>

3、 选择缓存策略依据：

<cache  usage="transactional|read-write|nonstrict-read-write|read-only" (1)/>
ehcache不支持transactional，其他三种可以支持。
read-only：无需修改， 那么就可以对其进行只读 缓存，注意，在此策略下，如果直接修改数据库，即使能够看到前台显示效果，
但是将对象修改至cache中会报error，cache不会发生作用。另：删除记录会报错，因为不能在read-only模式的对象从cache中删除。
" T5 _# M# t+ Q/ E) F  @/ U3 I( ?/ aread-write：需要更新数据，那么使用读/写缓存 比较合适，前提：数据库不可以为serializable transaction isolation level
（序列化事务隔离级别）
8 X& I$ S+ j* I' \% V: |nonstrict-read-write：只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，
那么比较适合使用非严格读/写缓存策略。

4、 调试时候使用log4j的log4j.logger.org.hibernate.cache=debug，更方便看到ehcache的操作过程，主要用于调试过程,实际应用发布时候，请注释掉，以免影响性能。

5、 使用ehcache，打印sql语句是正常的，因为query cache设置为true将会创建两个缓存区域：一个用于保存查询结果集 (
7 ], t! d2 g" rorg.hibernate.cache.StandardQueryCache)；另一个则用于保存最近查询的一系列表的时间戳(org.hibernate.cache.UpdateTimestampsCache)。
请注意：在查询缓存中，它并不缓存结果集中所包含的实体的确切状态；它只缓存这些实体的标识符属性的值、以及各值类型的结果。
3 |, L. G: B: p0 t需要将打印sql语句与最近的cache内容相比较，将不同之处修改到cache中，所以查询缓存通常会和二级缓存一起使用。

Ehcache的配置说明

<ehcache>
<!--
磁盘存储配置：
2 g/ H# m! y& B& |8 U用来指定缓存在磁盘上的存储位置。可以使用JavaVM环境变量(user.home, user.dir, java.io.tmpdir)
6 y( q) e$ G; p- W-->
<diskStore path = "/var/apps/cache/" />
<!--
: f: U. D2 }: u- O0 ], u9 i1 d: ~6 B指定CacheManagerEventListenerFactory，这个对象在缓存添加的时候会得到相应的通知
CacheManagerEventListenerFactory的属性
1 ]1 [( \2 E" j- G) y1 l*class - CacheManagerEventListenerFactory的一个实现类
9 |& T. s0 m5 T" Q*properties - CacheManagerEventListenerFactory的属性值，以逗号(,)分割多个属性
如果没有实现类被指定，则系统不创建CacheManager的监听器，没有默认值
-->
<cacheManagerEventListenerFactory class="" properties="" />
" D% C  [* b. K! ?3 @<!--
. w- k7 B3 w2 e" h) X7 q, ^* M% r在进行分布式缓存的应用时候需要指定CacheManagerPeerProviderFactory，
用来生成CacheManagerPeerProvider的实例，以便和集群中的其他CacheManager通信。
3 J$ w8 ^/ z5 a4 @) Z5 ~*class -CacheManagerPeerProviderFactory的一个实现类
*properties - CacheManagerPeerProviderFactory的属性值，以逗号(,)分割多个属性
0 N/ a% f/ p/ r9 M" A7 uEhcache内建了2种基于RMI分布系统的通信策略：
% O: f2 f5 l+ f3 L5 @+ c*automatic - 使用多播组。在一个节点加入或者推出集群的时候自动感应
1 [; ?6 q7 V2 A; z9 D' X*manual - 硬编码方式

目前的awf中不考虑分布缓存
-->
<cacheManagerPeerListenerFactory class="" properties="" />
<!--
: T$ ]* V; p0 g. T5 w8 t9 f缓存配置。
以下属性是必须的：
name - cache的标识符，在一个CacheManager中必须唯一
( I& [# B; k' j1 j' {maxElementsInMemory - 在内存中缓存的element的最大数目
8 F& o& L+ M. x1 [; ^& xmaxElementsOnDisk - 在磁盘上缓存的element的最大数目
2 l4 I0 b) {0 peternal - 设定缓存的elements是否有有效期。如果为true，timeouts属性被忽略
+ r; h. ^9 Q% v1 X% QoverflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
( |; u. ~' E: \) }( @以下属性是可选的：
: q7 j* E* k' d8 ^7 ^- TtimeToIdleSeconds - 缓存element在过期前的空闲时间。默认为0，表示可空闲无限时间.
        (如果指定了这个时间，是否在被hit的前超过了这个时间就会被remove？在内存缓存数目超限之前不会被remove)
7 _; @5 Y* I6 ItimeToLiveSeconds - 缓存element的有效生命期。这个类似于timeouts，默认为0，不过期
0 K9 X: A9 w0 T4 Z1 I        (是否通常情况下应该大于等于timeToIdleSeconds，小于会如何？idle时间也会减小和这个数值一样)
diskPersistent - 在VM重启的时候是否持久化磁盘缓存，默认是false。
        (测试一下true的情况？重载vm的时候会从磁盘进行序列化到对象)
6 o) @% K6 g# d& [diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒.
" q9 P% X; R* a        (测试一下0的时候会如何)
/ X+ R  d: g( n4 I$ @# [8 j& v0 E9 q8 BmemoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候，
3 W  t5 ]) K& I        移除缓存中element的策略。默认是LRU，可选的有LFU和FIFO

可对缓存中的element配置诸如监听器和加载器。Ehcahe内建了一些
*cacheEventListenerFactory - 监听缓存中element的put, remove, update和expire事件
*bootstrapCacheLoaderFactory - 启动时加载缓存的element
每个用来做分布式缓存都必须设定element的事件监听器，用来在各个CacheManager节点复制消息。
Ehcache内建了基于RMI的实现 - RMICacheReplicatorFactory
    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
        properties="replicateAsynchronouly=true,
        replicatePuts=true,
        replicateUpdates=true,
  [2 y1 f8 W: T8 i. f        replicateUpdateViaCopy=true,
        replicateRemovals=true" />

-->
<cache .... />
' z* |( p  U5 p6 @$ z<!--
默认的Cache配置。用来实现CacheManager.add(String cacheName)创建的缓存
-->
, M& n( p$ R! }' L<defaultCache maxElementsInMemory="10000" eternal="false"
6 n- [# X5 {6 X: N: R) f/ m; E        timeToIdleSeconds="120" timeToLiveSeconds="120"
        overflowToDisk="true" maxElementsOnDisk="1000000"
1 o  Y  j# @( [8 f4 k" }/ j        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU"
        />

</ehcache>