Spring基于注解的缓存配置--EHCache AND OSCache

本文将构建一个普通工程来说明spring注解缓存的使用方式，关于如何在web应用中使用注解缓存，请参见：

Spring基于注解的缓存配置--web应用实例

 

一.简介 
在spring的modules包中提供对许多第三方缓存方案的支持，包括： 
EHCache 
OSCache(OpenSymphony) 
JCS 
GigaSpaces 
JBoss Cache 
等等。 
将这些第三方缓存方案配置在spring中很简单，网上有许多介绍，这里只重点介绍如何配置基于注解的缓存配置。 
本文将通过例举EHCache和OSCache详细介绍如何使用spring配置基于注解的缓存配置，注意这里的缓存是方法级的。 

二.依赖 
在开始介绍如何进行缓存配置前先介绍一下EHCache和OSCache的jar依赖。 
EHCache： 
ehcache-core-1.7.2.jar 
jakarta-oro-2.0.8.jar 
slf4j-api-1.5.8.jar 
slf4j-jdk14-1.5.8.jar 

OSCache: 
oscache-2.4.1.jar 

此外，两者都需要的jar如下： 
cglib-nodep-2.1_3.jar 
commons-logging.jar 
log4j-1.2.15.jar 
spring-modules-cache.jar 
spring.jar 

三.配置

两种缓存在spring配置文件中都可以使用两种配置方式，一种是spring2.0以前的完全基于bean的复杂配置，一种是使用后来的基于命名空间的简单配置，两种配置效果相同，分别介绍如下：

EHCache： 
1）普通配置

 

[xhtml]  view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <beans xmlns="http://www.springframework.org/schema/beans"    
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans      
5.   http://www.springframework.org/schema/beans/spring-beans.xsd">    
6.     
7.     <!-- aop代理，这个是必须地，否则缓存不起作用 -->    
8.     <bean id="autoproxy"    
9.         class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />    
10.     
11.          
12.     <!-- EhCache 管理工厂 用于指定ehcache配置文件路径 -->    
13.     <bean id="cacheManager"    
14.         class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">    
15.         <property name="configLocation" value="classpath:ehcache.xml" />    
16.     </bean>    
17.     <bean id="cacheProviderFacade" class="org.springmodules.cache.provider.ehcache.EhCacheFacade">    
18.         <property name="cacheManager" ref="cacheManager" />    
19.     </bean>    
20.     
21.     
22.     <!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->    
23.     <bean id="cachingAttributeSource"    
24.         class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean>    
25.     <!-- 缓存拦截器:定义了缓存模块，ehcache只需要指定配置文件中的缓存名称 -->    
26.     <bean id="cachingInterceptor"    
27.         class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor">    
28.         <property name="cacheProviderFacade" ref="cacheProviderFacade" />    
29.         <property name="cachingAttributeSource" ref="cachingAttributeSource" />    
30.         <property name="cachingModels">    
31.             <props>    
32.                 <prop key="testCaching">cacheName=testCache</prop>    
33.             </props>    
34.         </property>    
35.     </bean>    
36.     
37.     <!-- 基于注解查找缓存业务方法的AOP通知器 -->    
38.     <bean id="cachingAttributeSourceAdvisor"    
39.         class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor">    
40.         <constructor-arg ref="cachingInterceptor" />    
41.     </bean>    
42.     
43.     <!-- 基于注解查找触发缓存刷新动作的业务方法 -->    
44.     <bean id="flushingAttributeSource"    
45.         class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean>    
46.     
47.     <!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存 -->    
48.    <bean id="flushingInterceptor"    
49.         class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor">    
50.         <property name="cacheProviderFacade" ref="cacheProviderFacade" />    
51.         <property name="flushingAttributeSource" ref="flushingAttributeSource" />    
52.         <property name="flushingModels">    
53.             <map>    
54.                 <entry key="testFlushing">    
55.                     <bean    
56.                         class="org.springmodules.cache.provider.ehcache.EhCacheFlushingModel">    
57.                              
58.                         <property name="cacheNames">    
59.                             <list>    
60.                                 <value>testCache</value>    
61.                             </list>    
62.                         </property>    
63.                               
64.                          <!-- 报错，应该是不能直接设置cacheName     
65.                          <property name="cacheName" value="testCache"/>                
66.                          -->              
67.                     </bean>    
68.                 </entry>    
69.             </map>    
70.     
71.         </property>    
72.     </bean>    
73.     
74.     <!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->    
75.     <bean id="flushingAttributeSourceAdvisor"    
76.         class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor">    
77.         <constructor-arg ref="flushingInterceptor" />    
78.     </bean>    
79.     
80.     <!-- 测试对象 -->    
81.     <bean id="testCache" class="com.TestCache"/>    
82.     
83. </beans>  

 

2）命名空间配置

 

[xhtml]  view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <beans xmlns="http://www.springframework.org/schema/beans"    
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ehcache="http://www.springmodules.org/schema/ehcache"    
4.     xsi:schemaLocation="     
5.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd     
6.             http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">    
7.     
8. <!-- 这里可以不需要配置这个     
9.     <bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />    
10.  -->    
11.          
12.     <ehcache:config configLocation="classpath:ehcache.xml"    
13.         id="cacheProvider" />    
14.     <ehcache:annotations providerId="cacheProvider">    
15.         <ehcache:caching cacheName="testCache" id="testCaching" />    
16.         <ehcache:flushing cacheNames="testCache" id="testFlushing" />    
17.     </ehcache:annotations>    
18.          
19.          
20.     <bean id="testCache" class="com.TestCache"/>       
21.     
22. </beans>  

 

 

OSCache： 
1）普通配置

 

[xhtml]  view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <beans xmlns="http://www.springframework.org/schema/beans"    
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans      
5.   http://www.springframework.org/schema/beans/spring-beans.xsd">    
6.     
7.     <!-- 这个是必须地，否则缓存不起作用 -->    
8.     <bean id="autoproxy"    
9.         class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />    
10.     
11.     <!-- 缓存管理工厂：使用OSCache缓存管理,配置了OSCache使用的配置文件路径 -->    
12.     <bean id="cacheManager"    
13.         class="org.springmodules.cache.provider.oscache.OsCacheManagerFactoryBean">    
14.         <property name="configLocation" value="classpath:oscache.properties" />    
15.     </bean>    
16.     <!-- 缓存提供：OSCache -->    
17.     <bean id="cacheProviderFacade" class="org.springmodules.cache.provider.oscache.OsCacheFacade">    
18.         <property name="cacheManager" ref="cacheManager" />    
19.     </bean>    
20.     
21.     
22.     
23.     <!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 -->    
24.     <bean id="cachingAttributeSource"    
25.         class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean>    
26.     
27.     <!-- 缓存拦截器:定义了缓存模块，以及相应的刷新策略，以及缓存所属群组 -->    
28.    <bean id="cachingInterceptor"    
29.         class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor">    
30.         <property name="cacheProviderFacade" ref="cacheProviderFacade" />    
31.         <property name="cachingAttributeSource" ref="cachingAttributeSource" />    
32.         <property name="cachingModels">    
33.             <props>    
34.                 <prop key="testCaching">refreshPeriod=86400;cronExpression=0 1 * * *;groups=pb_test</prop>    
35.             </props>    
36.         </property>    
37.     </bean>    
38.     
39.     <!-- 基于注解查找缓存业务方法的AOP通知器 -->    
40.     <bean id="cachingAttributeSourceAdvisor"    
41.         class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor">    
42.         <constructor-arg ref="cachingInterceptor" />    
43.     </bean>    
44.     
45.     <!-- 基于注解查找触发缓存刷新动作的业务方法 -->    
46.     <bean id="flushingAttributeSource"    
47.         class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean>    
48.     
49.     <!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存群组 -->    
50.     <bean id="flushingInterceptor"    
51.         class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor">    
52.         <property name="cacheProviderFacade" ref="cacheProviderFacade" />    
53.         <property name="flushingAttributeSource" ref="flushingAttributeSource" />    
54.         <property name="flushingModels">    
55.             <props>    
56.                 <prop key="testFlushing">groups=pb_test</prop>    
57.             </props>    
58.         </property>    
59.     </bean>    
60.     
61.     <!-- 基于注解查找刷新缓存业务方法的AOP通知器 -->    
62.     <bean id="flushingAttributeSourceAdvisor"    
63.         class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor">    
64.         <constructor-arg ref="flushingInterceptor" />    
65.     </bean>    
66.     
67.     <bean id="testCache" class="com.TestCache"/>    
68.     
69. </beans>  

 

2)命名空间配置

 

[xhtml]  view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <beans xmlns="http://www.springframework.org/schema/beans"    
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:oscache="http://www.springmodules.org/schema/oscache"    
4.     xsi:schemaLocation="     
5.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd     
6.             http://www.springmodules.org/schema/oscache http://www.springmodules.org/schema/cache/springmodules-oscache.xsd">    
7.     
8. <!-- 这里可以不需要配置这个     
9.     <bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />    
10.  -->    
11.          
12.     <oscache:config configLocation="classpath:oscache.properties" id="cacheProvider"/>    
13.          
14.     <oscache:annotations providerId="cacheProvider">    
15.         <oscache:caching id="testCaching" groups="pb_test" cronExpression="0 1 * * *" refreshPeriod="86400"/>    
16.         <oscache:flushing id="testFlushing" groups="pb_test"/>    
17.     </oscache:annotations>    
18.          
19.     <bean id="testCache" class="com.TestCache"/>    
20.          
21. </beans>  

 

四.注解

  @Cacheable：声明一个方法的返回值应该被缓存

例如：@Cacheable(modelId = "testCaching")

  @CacheFlush：声明一个方法是清空缓存的触发器

例如：@CacheFlush(modelId = "testCaching")

 

五.测试

  这是用使用一个带有main函数的类来进行测试，代码如下：

 

[java]  view plain copy

 

1. /*   
2. * COPYRIGHT Beijing NetQin-Tech Co.,Ltd.                                   *   
3. ****************************************************************************   
4. * 源文件名: TestCache.java                                                                
5. * 功能: （描述文件功能）                                                        
6. * 版本:   @version 1.0                                                                          
7. * 编制日期: 2010-2-24                                                             
8. * 说明: （描述使用文件功能时的制约条件）                                          
9. * 修改历史: (主要历史变动原因及说明)          
10. * YYYY-MM-DD |    Author      |  Change Description              
11. * 2010-2-24   |  hanqunfeng    |  Created    
12. */    
13. package com;     
14.     
15. import net.sf.ehcache.CacheManager;     
16.     
17. import org.springframework.context.ApplicationContext;     
18. import org.springframework.context.support.ClassPathXmlApplicationContext;     
19. import org.springmodules.cache.annotations.CacheFlush;     
20. import org.springmodules.cache.annotations.Cacheable;     
21.     
22. import com.opensymphony.oscache.general.GeneralCacheAdministrator;     
23.     
24. public class TestCache {     
25.     
26.     /**                                                             
27.      * 描述 : <描述函数实现的功能>. <br>   
28.      *<p>                                                    
29.                                                                                                                                                                                                              
30.      * @param args                                                                                                    
31.      */    
32.     static String context = null;     
33.     static ApplicationContext applicationContext;     
34.     
35.     static{     
36.         context = "applicationContext-ehcache.xml";//ehcache简单配置（命名空间）     
37. //      context = "applicationContext-ehcache_full.xml";//ehcache完整配置     
38. //      context = "applicationContext-oscache.xml";//oscache简单配置（命名空间）     
39. //      context = "applicationContext-oscache_full.xml";//oscache完整配置     
40.              
41.         applicationContext = new ClassPathXmlApplicationContext(context);     
42.     }     
43.     public static void main(String[] args) {     
44.         TestCache test = (TestCache)applicationContext.getBean("testCache");     
45.         System.out.println(test.getName(0));     
46.         System.out.println(test.getName(0));     
47.         System.out.println(test.getName(0));     
48.         test.flush();     
49. //      test.OSFlushAll();     
50. //      test.EHFlushAll();     
51.         System.out.println(test.getName(0));     
52.         System.out.println(test.getName(0));     
53.         System.out.println(test.getName(0));     
54.              
55.     
56.     }     
57.     @Cacheable(modelId = "testCaching")     
58.     public String getName(int i){     
59.         System.out.println("Processing testCaching");     
60.         return "nihao:"+i;     
61.     }     
62.          
63.     @CacheFlush(modelId = "testFlushing")     
64.     public void flush(){     
65.         System.out.println("Processing testFlushing");     
66.     }     
67.          
68.     /**                                                             
69.     * 描述 : <OSCache刷新全部缓存>. <br>   
70.     *<p>                                                    
71.          问题：flushAll() 后不会再缓存数据                                                                                                                                                                                                                                                                                                   
72.     */    
73.     public void OSFlushAll(){     
74.         GeneralCacheAdministrator cacheAdmin = (GeneralCacheAdministrator)applicationContext.getBean("cacheManager");     
75.         cacheAdmin.flushAll();     
76.         System.out.println("Processing OSFlushingAll");     
77.     }     
78.          
79.     /**                                                             
80.     * 描述 : <清空指定组名称的缓存>. <br>   
81.     *<p>                                                    
82.                                                                                                                                                                                                              
83.     * @param groupName                                                                                                    
84.     */    
85.     public void OSFlushGroup(String groupName){     
86.         GeneralCacheAdministrator cacheAdmin = (GeneralCacheAdministrator)applicationContext.getBean("cacheManager");     
87.         cacheAdmin.flushGroup(groupName);//清除该组的缓存：pb_test     
88.         System.out.println("Processing OSFlushingGroup:"+groupName);     
89.     }     
90.          
91.     /**                                                             
92.     * 描述 : <EHCache刷新全部缓存>. <br>   
93.     *<p>                                                    
94.         success                                                                                                                                                                                                                                                                                   
95.     */    
96.     public void EHFlushAll(){     
97.         CacheManager cacheAdmin = (CacheManager)applicationContext.getBean("cacheManager");     
98.         cacheAdmin.clearAll();       
99.         System.out.println("Processing EHFlushingAll");     
100.     }     
101.          
102.     /**                                                             
103.     * 描述 : <清空指定名称的缓存>. <br>   
104.     *<p>                                                    
105.                                                                                                                                                                                                              
106.     * @param cacheName                                                                                                    
107.     */    
108.     public void EHFlushCache(String cacheName){     
109.         CacheManager cacheAdmin = (CacheManager)applicationContext.getBean("cacheManager");     
110.         cacheAdmin.getCache(cacheName).flush();//清除单个缓存:testCache        
111.         System.out.println("Processing EHFlushingCacheName:"+cacheName);     
112.     }     
113.          
114.     
115. }   

测试结果

Processing testCaching
nihao:0
nihao:0
nihao:0
Processing testFlushing
Processing testCaching
nihao:0
nihao:0
nihao:0

 

六.缓存配置文件

ehcache.xml

 

[xhtml]  view plain copy

 

1. <?xml version="1.0" encoding="UTF-8"?>    
2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
3.     xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"    
4.     monitoring="autodetect">    
5.     <diskStore path="java.io.tmpdir"/>    
6.     <defaultCache    
7.             maxElementsInMemory="10000"    
8.             eternal="false"    
9.             timeToIdleSeconds="120"    
10.             timeToLiveSeconds="120"    
11.             overflowToDisk="true"    
12.             maxElementsOnDisk="10000000"    
13.             diskPersistent="false"    
14.             diskExpiryThreadIntervalSeconds="120"    
15.             memoryStoreEvictionPolicy="LRU"    
16.             />    
17.      <cache name="testCache"    
18.            maxElementsInMemory="10000"    
19.            maxElementsOnDisk="1000"    
20.            eternal="false"    
21.            overflowToDisk="true"    
22.            diskSpoolBufferSizeMB="20"    
23.            timeToIdleSeconds="300"    
24.            timeToLiveSeconds="600"    
25.            memoryStoreEvictionPolicy="LFU"    
26.             />    
27. </ehcache>  

 

oscache.properties

 

[xhtml]  view plain copy

 

1. cache.capacity=5000