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

莫小柒

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

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
3 j3 p' ^* ^- Y9 o1 N+ Q　<diskStore path="java.io.tmpdir"/>
　　<defaultCache
' _4 `8 j, m$ Y; q( v　　　maxElementsInMemory="10000" <!-- 缓存最大数目 -->
　　　eternal="false" <!-- 缓存是否持久 -->

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

　　　timeToIdleSeconds="300" <!-- 当缓存闲置n秒后销毁 -->
　　　timeToLiveSeconds="180" <!-- 当缓存存活n秒后销毁-->
　　　diskPersistent="false"
7 @7 i0 h' R6 z2 c　　　diskExpiryThreadIntervalSeconds= "120"/>
0 X1 C: r! t1 C/ \! c</ehcache>

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

<!-- 设置Hibernate的缓存接口类，这个类在Hibernate包中 -->
* o6 `9 O. x/ I; v<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
# L; k" |' X; }7 Q$ U$ E　<!-- 是否使用查询缓存 -->

　<property name="hibernate.cache.use_query_cache">true</property>
2 K( P  }. `8 g7 e　　如果使用spring调用Hibernate的sessionFactory的话，这样设置：
　　<!--HibernateSession工厂管理 -->

　　　<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
　　　<property name="dataSource">
1 g( G+ a) o5 F. y* ~8 A. z! w7 y　　　　<ref bean="datasource" />
　　　</property>
　　　<property name="hibernateProperties">
6 v4 o' l0 W0 T1 E4 e　　　<props>
) U' v' F3 ~8 p' V( x2 R: d　　　　<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
: C$ v4 k* S) ^' ^　　　  <prop key="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</prop>
5 O* x* R* s0 Z　　　　<prop key="hibernate.show_sql">true</prop>
　　　　<prop key="hibernate.cache.use_query_cache">true</prop>
# o0 i  h  v0 Y* W9 N) j+ u　　　　<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
　　　</props>
0 F1 w; m! a) {3 H7 K　</property>
$ X' }/ L6 h. X# ~4 o　<property name="mappingDirectoryLocations">
　　<list>
$ c: a2 X/ Z; J, J　　　<value>/WEB-INF/classes/cn/rmic/manager/hibernate/</value>
0 F% f2 ^5 N; ~( \& A　　</list>
　</property>
</bean>

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

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

" }6 M# H$ ~7 g' D) h+ S7 {9 j0 ]　　4、如果需要“查询缓存”，还需要在使用Query或Criteria()时设置其setCacheable(true);属性

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

package cn.rmic.hibernatesample;

import java.util.List;

import org.hibernate.CacheMode;
3 z) \- d) u. jimport org.hibernate.Criteria;
* x; J/ x1 \5 Z! [  _; A. yimport org.hibernate.Query;
% Q5 D: ]. [5 F- b: Wimport org.hibernate.Session;

import cn.rmic.hibernatesample.hibernate.HibernateSessionFactory;
import cn.rmic.manager.po.Resources;

public class testCacheSelectList ...{

　public static void main(String[] args) ...{
　　Session s=HibernateSessionFactory.getSession();
6 Q  M+ a7 y0 p! F9 z　　Criteria c=s.createCriteria(Resources.class);
1 i+ G5 b$ B7 P7 y7 r' e1 o　　c.setCacheable(true);
　　List l=c.list();

　　Resources resources=(Resources)l.get(0);
0 g9 r% e2 b, g0 |4 T; g% C　　System.out.println("-1-"+resources.getName());
　　HibernateSessionFactory.closeSession();

　　try ...{
( y5 J$ {- J; ]  {: S- A) I& A5 w　　　Thread.sleep(5000);
  \, k: N2 n& Y2 O4 S　　} catch (InterruptedException e) ...{
　　　// TODO Auto-generated catch block
　　　e.printStackTrace();
　　}
4 q: ~% Z& R6 x2 b  y9 k- |　　s=HibernateSessionFactory.getSession();
' Y8 Y# ^, Z- Z5 B　　c=s.createCriteria(Resources.class);
' X+ c4 W* ~, A" ~: N. u　　c.setCacheable(true);
　　l=c.list();
: E$ @" k+ A. [' I% j  S" n6 A　　resources=(Resources)l.get(0);
　　System.out.println("-2-"+resources.getName());
　　HibernateSessionFactory.closeSession();
　}
}

1 x: {8 ]  N. ~; f! y; [" g

1. 在Hibernate配置文件中设置：
4 @4 I) ^0 J: k4 g% v   

<!-- Hibernate SessionFactory -->
5 x! R# o. o7 n5 l" s+ C    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
2 p- n, c" p5 I' L        <property name="mappingResources">
/ Q, C( p4 P3 R$ x5 C6 r  c        <list>
            <value>com/ouou/model/Videos.hbm.xml</value>  
: B5 R; X! k3 V/ h9 u" |* X         </list>
4 I) \' k# }& W2 l* W         </property>
1 H" L* g' s3 \% r5 t2 w6 x# r2 i        <property name="hibernateProperties">
- _. o( t5 G  w' Z* T2 C) S            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
& H) X0 \8 n4 |# a$ q8 W                <prop key="hibernate.current_session_context_class">thread</prop>
                <prop key="hibernate.cglib.use_reflection_optimizer">false</prop>
                <prop key="hibernate.query.substitutions">true 'Y', false 'N'</prop>
$ G; p9 T( g& A8 z! E1 M                <!--add ehcache-->
+ l7 S! F- ?* @" o: g, T/ f                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
6 U5 B# B" K4 F                <prop key="hibernate.cache.use_query_cache">false</prop><!-- 是否使用查询缓存 -->
                <!--
; c1 i/ \! o/ p2 B4 e+ M: g                <prop key="hibernate.cache.provider_configuration_file_resource_path">/ehcache.xml</prop>
% A% w  C8 O1 ^3 _& _0 j' g                <prop key="hibernate.show_sql">true</prop>
                -->
                <!--<prop key="hibernate.transaction.auto_close_session">true</prop>-->
' x( I" n6 B3 D9 B. ^. y                <prop key="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</prop>
* i- I( `$ N8 q) B                <!-- Create/update the database tables automatically when the JVM starts up
                 <prop key="hibernate.hbm2ddl.auto">update</prop> -->
' p& h' O+ ?- X. F; z6 Q% u                <!-- Turn batching off for better error messages under PostgreSQL -->
' H) r5 n/ q! W0 j$ ^                <prop key="hibernate.jdbc.batch_size">25</prop>
* }+ S0 R: t5 J. g& R3 c; O  K                <!--
                <prop key="hibernate.connection.pool_size">10</prop>
                -->
3 b/ v/ B, L' K. c+ R            </props>
4 D' V' w: P3 [        </property>
0 F6 z& [' V6 @- T+ p0 ?$ ~    </bean>

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

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

) `! K7 y, _/ ?/ F' ^4 P' h. v <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
     its value in the running VM.
     The following properties are translated:
     user.home - User's home directory
     user.dir - User's current working directory
     java.io.tmpdir - Default temp file path -->
     <!--<diskStore path="java.io.tmpdir"/>-->
     <diskStore path="/data/ehcache"/>

    <!--Default Cache configuration. These will applied to caches programmatically created through
' V$ |6 |5 n7 \; Y; K        the CacheManager.

        The following attributes are required:

        maxElementsInMemory            - Sets the maximum number of objects that will be created in memory
# r3 d- c: L8 U( \        eternal                                     - Sets whether elements are eternal. If eternal,  timeouts are
. W- c  Z0 g$ T5 P                                                            ignored and the element is never expired.
        overflowToDisk                      - Sets whether elements can overflow to disk when the in-memory cache
6 S: n/ `. A/ m  ?  E: z9 X9 v                                                        has reached the maxInMemory limit.

        The following attributes are optional:
        timeToIdleSeconds            - Sets the time to idle for an element before it expires.
6 ~% ]4 l: H$ ?+ e7 D" Q4 \                                                        i.e. The maximum amount of time between accesses before an
$ a7 S  `, A5 P3 I                                                        element expires Is only used if the element is not eternal.
" J- V! c' Q# \0 {/ S                                                        Optional attribute. A value of 0 means that an Element can idle
                                                        for infinity.The default value is 0.
  N! N5 t1 n* s; a+ i) r        timeToLiveSeconds              - Sets the time to live for an element before it expires.
                                                         i.e. The maximum time between creation time and when an element
6 L# \6 o  b( r) R% P7 L                                                         expires.  Is only used if the element is not eternal.
                                                         Optional attribute. A value of 0 means that and Element can live
% z# b  t+ h7 m1 g" ~                                                         for infinity.
                                                        The default value is 0.
        diskPersistent                           - Whether the disk store persists between restarts of the Virtual
. z8 ?( C6 E+ a. T2 f( T                                                             Machine.
) p) y3 {0 b/ _6 z. r( \& `' `2 x                                                         The default value is false.
        diskExpiryThreadIntervalSeconds   - The number of seconds between runs of the disk expiry thread.
, f8 @) u. R" w7 q                                                         The default value  is 120 seconds.
% t5 S' j1 a" F% J7 N' S! F        -->

    <defaultCache
0 o+ x: r5 f4 P; V$ q7 M        maxElementsInMemory="10000"
        eternal="false"
        overflowToDisk="true"
- _4 I3 E) ~1 q& n' O        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
6 t# [* w) e2 b2 O; l4 C0 Y        diskPersistent="false"
& b' p* N. {) G        diskExpiryThreadIntervalSeconds="120"/>
    <cache name="org.hibernate.cache.UpdateTimestampsCache" maxElementsInMemory="5000"
     eternal="true" overflowToDisk="true"/>
9 |- U0 {$ G$ ]* X    <cache name="org.hibernate.cache.StandardQueryCache" maxElementsInMemory="5" eternal="false"
! Q7 z, u+ l) Q: \0 R% e( I! t    timeToLiveSeconds="120" overflowToDisk="true"/>
    <cache name="userCache" maxElementsInMemory="100000" eternal="false" timeToIdleSeconds=
; I5 c" n' B' z8 S' \  Q: |        "600"    timeToLiveSeconds="600" overflowToDisk="false" diskPersistent="false"/>
    <cache name="com.ouou.webapp.util.OuouMethodIntecepter" maxElementsInMemory="100000"
' S6 O; f- y; v; a    eternal="false" timeToIdleSeconds="600" timeToLiveSeconds="600" overflowToDisk="false"
    diskPersistent="false"/>
) I, H# E8 b% @( U3 F3 T/ `    <cache name="bbcode" maxElementsInMemory="100000" eternal="false" timeToIdleSeconds="600"
* Y5 y( K( m! `( V+ C; D0 ^    timeToLiveSeconds="600"
/ H# d# R1 o& q' N    overflowToDisk="false" diskPersistent="false"/>
    <cache name="com.ouou.model.Videos" maxElementsInMemory="10000"  eternal="false"
1 h. y7 m6 _3 f4 u6 e! y0 O; Y    overflowToDisk="false" timeToIdleSeconds="120" timeToLiveSeconds="120" diskPersistent="false"/>
5 f' A# k+ j( \, Y    <cache name="com.ouou.model.Tags" maxElementsInMemory="10000"  eternal="false"
    overflowToDisk="false" timeToIdleSeconds="120" timeToLiveSeconds="120" diskPersistent="false"/>
3 u! T/ N/ a- O) X9 O. `+ ?# `</ehcache>

以com.ouou.model.Videos为例子
在Videos.hbm.xml中配置：
<class name="Videos" table="TEST" lazy="false">
& M$ K# G  t4 b6 d9 _& Z# [  <cache usage="read-write" region="ehcache.xml中的name的属性值"/>注意：这一句需要紧跟在class标签下面，其他位置无效。
hbm文件查找cache方法名的策略：如果不指定hbm文件中的region="ehcache.xml中的name的属性值"，则使用name名为com.ouou.model.Videos的cache，
2 t& S- W, z7 m2 N$ \" R如果不存在与类名匹配的cache名称，则用defaultCache。
5 D$ {' W& {$ {0 Y如果Videos包含set集合，则需要另行指定其cache
, P1 J$ C8 t0 U" K7 }0 s& E' r例如Videos包含Tags集合，则需要
添加如下配置到ehcache.xml中
2 l! i0 }* D% ?( _' O/ e; r( d  i) g<cache name="com.ouou.model.Tags"
        maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120"
        timeToLiveSeconds="120" overflowToDisk="false" />
另，针对查询缓存的配置如下：
. B, U' ~3 [# f& u7 O1 v& `<cache name="org.hibernate.cache.UpdateTimestampsCache"
. M" S4 Y, ]/ F+ L  o        maxElementsInMemory="5000"
+ W/ L" h0 b2 \4 `5 w* {" @9 |        eternal="true"
        overflowToDisk="true"/>
( I  A2 D9 o$ i4 I* P8 m/ c<cache name="org.hibernate.cache.StandardQueryCache"
' @$ |1 R3 `# A' c8 F+ S        maxElementsInMemory="10000"
6 ^$ \) v5 w4 W6 H+ _/ o        eternal="false"
        timeToLiveSeconds="120"
        overflowToDisk="true"/>

3、 选择缓存策略依据：

<cache  usage="transactional|read-write|nonstrict-read-write|read-only" (1)/>
ehcache不支持transactional，其他三种可以支持。
* }! k# S0 ?- u7 E( H( j2 {read-only：无需修改， 那么就可以对其进行只读 缓存，注意，在此策略下，如果直接修改数据库，即使能够看到前台显示效果，
但是将对象修改至cache中会报error，cache不会发生作用。另：删除记录会报错，因为不能在read-only模式的对象从cache中删除。
% @7 d6 q6 X8 i6 R8 Kread-write：需要更新数据，那么使用读/写缓存 比较合适，前提：数据库不可以为serializable transaction isolation level
（序列化事务隔离级别）
nonstrict-read-write：只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，
7 R3 Q. d, o. u: Y' g% X那么比较适合使用非严格读/写缓存策略。

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

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

Ehcache的配置说明

<ehcache>
$ v; G- n! [; q2 `7 y<!--
. E% ]: [0 D8 U5 s$ V7 y磁盘存储配置：
用来指定缓存在磁盘上的存储位置。可以使用JavaVM环境变量(user.home, user.dir, java.io.tmpdir)
! s0 X) {1 f% k6 V: U" t0 X% u-->
- F0 G+ F7 S0 U  D/ O' d% o<diskStore path = "/var/apps/cache/" />
<!--
指定CacheManagerEventListenerFactory，这个对象在缓存添加的时候会得到相应的通知
CacheManagerEventListenerFactory的属性
4 r* [" ~3 r' l3 L( ]! }/ \*class - CacheManagerEventListenerFactory的一个实现类
/ f+ ^0 d, h4 E" ~$ A7 v*properties - CacheManagerEventListenerFactory的属性值，以逗号(,)分割多个属性
- A! K) A# r) |( Y0 F如果没有实现类被指定，则系统不创建CacheManager的监听器，没有默认值
-->
) x. V; ^/ q1 w2 W" S' B<cacheManagerEventListenerFactory class="" properties="" />
& e( j: w, T0 y2 J0 H6 h5 U<!--
7 D( n( ?1 |: l0 e7 ~; C% p在进行分布式缓存的应用时候需要指定CacheManagerPeerProviderFactory，
& o) N# u' a0 m6 K* X! j, C1 p用来生成CacheManagerPeerProvider的实例，以便和集群中的其他CacheManager通信。
*class -CacheManagerPeerProviderFactory的一个实现类
3 y, \3 u4 R. T9 A3 r' P*properties - CacheManagerPeerProviderFactory的属性值，以逗号(,)分割多个属性
- [6 p; A* n) r0 J+ UEhcache内建了2种基于RMI分布系统的通信策略：
*automatic - 使用多播组。在一个节点加入或者推出集群的时候自动感应
*manual - 硬编码方式

目前的awf中不考虑分布缓存
-->
<cacheManagerPeerListenerFactory class="" properties="" />
<!--
" K  O3 x( b9 N缓存配置。
以下属性是必须的：
4 T( c$ M6 w/ yname - cache的标识符，在一个CacheManager中必须唯一
maxElementsInMemory - 在内存中缓存的element的最大数目
3 p4 U' l9 u# R- ^! e% ^maxElementsOnDisk - 在磁盘上缓存的element的最大数目
( |: |' P+ a# W9 [, G( Heternal - 设定缓存的elements是否有有效期。如果为true，timeouts属性被忽略
overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
# h+ e. P! y( QtimeToIdleSeconds - 缓存element在过期前的空闲时间。默认为0，表示可空闲无限时间.
        (如果指定了这个时间，是否在被hit的前超过了这个时间就会被remove？在内存缓存数目超限之前不会被remove)
timeToLiveSeconds - 缓存element的有效生命期。这个类似于timeouts，默认为0，不过期
# o  L! A) b+ u7 L3 `        (是否通常情况下应该大于等于timeToIdleSeconds，小于会如何？idle时间也会减小和这个数值一样)
  ^. t$ l; c$ BdiskPersistent - 在VM重启的时候是否持久化磁盘缓存，默认是false。
        (测试一下true的情况？重载vm的时候会从磁盘进行序列化到对象)
diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒.
        (测试一下0的时候会如何)
memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候，
* I* t5 r, N# L) o  c        移除缓存中element的策略。默认是LRU，可选的有LFU和FIFO

可对缓存中的element配置诸如监听器和加载器。Ehcahe内建了一些
*cacheEventListenerFactory - 监听缓存中element的put, remove, update和expire事件
*bootstrapCacheLoaderFactory - 启动时加载缓存的element
每个用来做分布式缓存都必须设定element的事件监听器，用来在各个CacheManager节点复制消息。
( P% F9 O5 G$ N; d0 s/ Y) ]/ REhcache内建了基于RMI的实现 - RMICacheReplicatorFactory
    <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
& P: M; b. _$ X6 d        properties="replicateAsynchronouly=true,
        replicatePuts=true,
( N7 v( ]- o' o$ }        replicateUpdates=true,
        replicateUpdateViaCopy=true,
4 a$ D7 m2 Y5 n) _+ o  X0 \6 l        replicateRemovals=true" />

-->
: O! C. b3 J/ Z; h<cache .... />
<!--
/ s6 l' H( a3 c& g默认的Cache配置。用来实现CacheManager.add(String cacheName)创建的缓存
-->
<defaultCache maxElementsInMemory="10000" eternal="false"
7 Y5 G# A: [5 u: ?, K3 `0 ?- c        timeToIdleSeconds="120" timeToLiveSeconds="120"
        overflowToDisk="true" maxElementsOnDisk="1000000"
        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
) ^' d' J, g+ \        memoryStoreEvictionPolicy="LRU"
        />

</ehcache>