使用spring和hibernate配置ehcache和query cache

luinstein

ehcache.xml:

1. <ehcache>
   
2. <!-- maxElementsInMemory为缓存对象的最大数目,
   
3.   eternal设置是否永远不过期,timeToIdleSeconds对象处于空闲状态的最多秒数,
   
4.   timeToLiveSeconds对象处于缓存状态的最多秒数
   
5. 
   
6.   overflowToDisk指达到上限，则保存到磁盘 -->
   
7. <diskStore path="c://tao" />
   
8. <defaultCache     maxElementsInMemory="5000"
   
9.   　　　　　　     eternal="false"
   
10.                                timeToIdleSeconds="300"
    
11.                                timeToLiveSeconds="600"
    
12.                                overflowToDisk="true" />
    
13. 
    
14. <cache                 name="forvercache"
    
15.                                maxElementsInMemory="3000"
    
16.                                eternal="true"
    
17.                                timeToIdleSeconds="0"
    
18.                                timeToLiveSeconds="0"
    
19.                                overflowToDisk="false"  />

复制代码

applicationContext-dao.xml:

1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
   
2. 　　　　<property name="dataSource" ref="dataSource" />
   
3. 
   
4.   　　　 <property name="hibernateProperties">
   
5.                 　　　　<value>
   
6.     　　　　　　　　　　　hibernate.show_sql=true
   
7. 　　　　　　　　　　　　hibernate.dialect=${hibernate.dialect}
   
8. 　　　　　　　　　　　　hibernate.query.substitutions=true 'Y', false 'N'
   
9. 　　　　　　　　　　　　hibernate.jdbc.fetch_size=${hibernate.jdbc.fetch_size}
   
10.     　　　　　　　　　　　hibernate.jdbc.batch_size=${hibernate.jdbc.batch_size}
    
11.     　　　　　　　　　　　hibernate.cache.use_second_level_cache=true
    
12.     　　　　　　　　　　　hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
    
13.     　　　　　　　　　　　hibernate.cache.use_query_cache=true
    
14. 　　　　　　　　</value>
    
15. 
    
16. 　　　　</property>
    
17. 
    
18. 　　　　<!-- *SPRING统一管理二级缓存配置 -->
    
19. 　　　　<property name="entityCacheStrategies" >
    
20. 　　　　　　　<props>
    
21.     　　　　　　　　　　<prop key="com.pzh.model.TCard">read-only,forvercache</prop>　　　　　　　　　　　　　　　　　　　　<!-- forvercache(在ehcache.xml里定义，不指定则使用默认) -->
    
22.     　　　　　　　　　　<prop key="com.pzh.model.Account">read-only</prop>
    
23.     　　　　　　　　　　<prop key="com.pzh.model.News">read-only</prop>
    
24.     　　　　　　</props>
    
25. 　　　　</property>
    
26. 　　　　<!-- 二级缓存中对应的set集合，只缓存某个对象所对应的set部分 -->
    
27. 　　　　<property name="collectionCacheStrategies">
    
28. 　　　　　　　　<props>
    
29. 　　　　　　　　　　　　<prop key="com.pzh.model.City.areaslist">read-only,forvercache</prop>
    
30. 　　　　　　　　　　　　<prop key="com.pzh.model.Areas.streetlist">read-only,forvercache</prop>
    
31. 　　　　　　　　</props>
    
32. 　　　　</property>
    
33. 
    
34. </bean>
    

复制代码

将ehcache.xml拷贝在src下，我在applicationcontext-dao.xml加了二级缓存启动配置和查询缓存开启。如果lib中有多个echecah,jar，请留下ehcache-1.4.1.jar；


我已经将某些dao文件的方法开启了查询缓存（哪些使用query查询的语句，另session或hibernatetemplate的get和load本来就存取二级缓存）



=================================================================

1.EhCache是什么
　　EhCache是Hibernate的二级缓存技术之一，可以把查询出来的数据存储在内存或者磁盘，节省下次同样查询语句再次查询数据库，大幅减轻数据库压力；

2.EhCache的使用注意点
　　当用Hibernate的方式修改表数据(save,update,delete等等)，这时EhCache会自动把缓存中关于此表的所有缓存全部删除掉(这样能达到同步)。但对于数据经常修改的表来说，可能就失去缓存的意义了(不能减轻数据库压力)；

3.EhCache使用的场合
　　3.1比较少更新表数据
　　　   EhCache一般要使用在比较少执行write操作的表(包括update,insert,delete等)[Hibernate的二级缓存也都是这样]；
　　3.2对并发要求不是很严格的情况
         　  两台机子中的缓存是不能实时同步的；

4.在项目做的实现
    4.1在工程的src目录下添加ehcache.xml文件，内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<ehcache>   　
　　　　<diskStore path="java.io.tmpdir" />
　　　　<defaultCache maxElementsInMemory="5"<!--缓存可以存储的总记录量-->
　　　　　　　　eternal="false"<!--缓存是否永远不销毁-->
　　　　　　　　overflowToDisk="true"<!--当缓存中的数据达到最大值时，是否把缓存数据写入磁盘-->
　　　　　　　　timeToIdleSeconds="15"<!--当缓存闲置时间超过该值，则缓存自动销毁-->
　　　　　　　　timeToLiveSeconds="120"<!--缓存创建之后，到达该缓存自动销毁-->
　　　　/>
</ehcache>
    4.2在Hibernate.cfg.xml中的mapping标签上面加以下内容：
　　　　<property name="show_sql">true</property>
　　　　<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
　　　　<property name="hibernate.cache.use_query_cache">true</property>
    4.3在要缓存的bean的hbm.xml文件中的class标签下加入以下内容：
　　　　<cache usage="read-only" /><!--也可读写-->
    4.4创建DAO，内容如下：
　　　　Session s = HibernateSessionFactory.getSession();
　　　　Criteria c = s.createCriteria(TCard.class);
　　　　c.setCacheable(true);//这句必须要有
　　　　System.out.println("第一次读取");
　　　　List l = c.list();
　　　　System.out.println(l.size());
　　　　HibernateSessionFactory.closeSession();
　　　　s = HibernateSessionFactory.getSession();
　　　　c = s.createCriteria(Xyz.class);
　　　　c.setCacheable(true);//这句必须要有
　　　　System.out.println("第二次读取");
　　　　l = c.list();
　　　　System.out.println(l.size());
　　　　HibernateSessionFactory.closeSession();
   4.5这时你会看到打印出来的信息为（表示第二次并没有去读库）：
　　　　第一次读取
　　　　Hibernate: *******
　　　　13
　　　　第二次读取
　　　　13



配置Spring+hibernate使用ehcache作为second-level cache

　　大量数据流动是web应用性能问题常见的原因，而缓存被广泛的用于优化数据库应用。cache被设计为通过保存从数据库里load的数据来减少应用和数据 库之间的数据流动。数据库访问只有当检索的数据不在cache里可用时才必要。hibernate可以用两种不同的对象缓存：first-level cache 和 second-level cache。first-level cache和Session对象关联，而second-level cache是和Session Factory对象关联。

        缺省地，hibernate已经使用基于每个事务的first-level cache。 Hibernate用first-level cache主要是减少在一个事务内的sql查询数量。例如，如果一个对象在同一个事务内被修改多次，hibernate将只生成一个包括所有修改的 UPDATE SQL语句。为了减少数据流动，second-level cache在Session Factory级的不同事务之间保持load的对象，这些对象对整个应用可用，不只是对当前用户正在运行的查询。这样，每次查询将返回已经load在缓存 里的对象，避免一个或更多潜在的数据库事务。

下载ehcache，hibernate3.2必须要ehcache1.2以上才能支持。可以修改log4j配置文件log4j.logger.net.sf.hibernate.cache=debug查看日志

1.在类路径上ehcache.xml：

　　　　<ehcache>

　　　　　　　　<diskStore path="java.io.tmpdir"/>

　　　　　　　　<defaultCache
　　　　　　　　　　　　maxElementsInMemory="10000"
　　　　　　　　　　　　eternal="false"
　　　　　　　　　　　　overflowToDisk="true"
　　　　　　　　　　　　timeToIdleSeconds="120"
　　　　　　　　　　　　timeToLiveSeconds="120"
　　　　　　　　　　　　diskPersistent="false"
　　　　　　　　　　　　diskExpiryThreadIntervalSeconds="120"/>
　　　　</ehcache>

2.applicationContext-hibernate.xml里Hibernate SessionFactory配置：

　　　　<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
　　　　　　　　<property name="dataSource" ref="dataSource"/>
　　　　　　　　<property name="configLocation"><value>classpath:hibernate.cfg.xml</value></property>
　　　　　　　　<property name="hibernateProperties">
　　　　　　　　<props>
                 　　　　　　　　<prop key="hibernate.dialect">@HIBERNATE-DIALECT@</prop>
                 　　　　　　　　<!--<prop key="hibernate.show_sql">true</prop>-->
                 　　　　　　　　<prop key="hibernate.max_fetch_depth">3</prop>
                 　　　　　　　　<prop key="hibernate.hibernate.use_outer_join">true</prop>
                 　　　　　　　　<prop key="hibernate.jdbc.batch_size">10</prop>
　　　　　　　　　　　　<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>
　　　　　　　　　　　　   <!--
　　　　　　　　　　　　   <prop key="hibernate.use_sql_comments">false</prop>
                 　　　　　　　　 -->
　　　　　　　　</props>
　　　　　　　　</property>
　　　　　　　　<property name="entityInterceptor">
　　　　　　　　　　　　<ref local="auditLogInterceptor"/>
　　　　　　　　</property>
　　　　</bean>
说明：如果不设置“查询缓存”，那么hibernate只会缓存使用load()方法获得的单个持久化对象，如果想缓存使用findall()、 list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话，就需要设置 hibernate.cache.use_query_cache true 才行

3.model类里采用Xdoclet生成*.hbm.xml里的cache xml标签，即<cache usage="read-only"/>

/**
* @hibernate.class table="WF_WORKITEM_HIS"
* @hibernate.cache usage="read-write"
*
*/


4.对于"query cache"，需要在程序里编码：

　　　　getHibernateTemplate().setCacheQueries(true);
　　　　return getHibernateTemplate().find(hql);





使用spring和hibernate配置ehcache和query cache

1、applicationContext.xml
<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
<prop key="hibernate.cache.use_query_cache">true</prop>
这两句加到hibernateProperties中
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
　　　　<property name="sessionFactory">
　　　　　　　　<ref bean="sessionFactory" />
　　　　</property>
　　　　<property name="cacheQueries">
　　　　　　　　<value>true</value>
　　　　</property>
</bean>

添加此bean到applicationcontext.xml中。在各个DAO的bean中，更改如下
<property name="sessionFactory">
　　　　<ref bean="sessionFactory" />
</property>
改为
<property name="hibernateTemplate">
　　　　<ref bean="hibernateTemplate" />
</property>

2、ehcache.xml文件放在classes根目录即可

3、pojo与ehcache.xml的配置关系
以com.ce.ceblog.pojos.CeblogJournal为例子
在CeblogJournal.hbm.xml中配置：
<class name="CeblogJournal" table="CEBLOG_JOURNAL" lazy="false">
<cache usage="read-write" region="ehcache.xml中的name的属性值"/>
注意：这一句需要紧跟在class标签下面，其他位置无效。

Ehcache.xml文件主体如下
<defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="1" timeToLiveSeconds="1" overflowToDisk="true" />
<cache name="com.ce.ceblog.pojos.CeblogJournal" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" />
hbm文件查找cache方法名的策 略：如果不指定hbm文件中的region="ehcache.xml中的name的属性值"，则使用name名为 com.ce.ceblog.pojos.CeblogJournal的cache，如果不存在与类名匹配的cache名称，则用 defaultCache。
如果CeblogJournal包含set集合，则需要另行指定其cache
例如CeblogJournal包含ceblogReplySet集合，则需要
添加如下配置到ehcache.xml中
<cache   name="com.ce.ceblog.pojos.CeblogJournal.ceblogReplySet"
　　　　maxElementsInMemory="10000"

　　　　eternal="false"

　　　　timeToIdleSeconds="300"
　　　　timeToLiveSeconds="600"

　　　　overflowToDisk="true" />

另，针对查询缓存的配置如下：
<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"/>

4、选择缓存策略依据：
<cache usage="transactional|read-write|nonstrict-read-write|read-only" />
ehcache不支持transactional，其他三种可以支持。
read- only：无需修改， 那么就可以对其进行只读 缓存，注意，在此策略下，如果直接修改数据库，即使能够看到前台显示效果，但是将对象修改至cache中会报error，cache不会发生作用。另：删 除记录会报错，因为不能在read-only模式的对象从cache中删除。
read-write：需要更新数据，那么使用读/写缓存 比较合适，前提：数据库不可以为serializable transaction isolation level（序列化事务隔离级别）
nonstrict-read-write：只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，那么比较适合使用非严格读/写缓存策略。

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

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

from:http://go.cxweb.com.cn/v11hv