spring缓存配置

 

本文将构建一个普通工程来说明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）普通配置

 

Xml代码  

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>  

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- aop代理，这个是必须地，否则缓存不起作用 --><bean id="autoproxy"class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" /><!-- EhCache 管理工厂 用于指定ehcache配置文件路径 --><bean id="cacheManager"class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"><property name="configLocation" value="classpath:ehcache.xml" /></bean><bean id="cacheProviderFacade" class="org.springmodules.cache.provider.ehcache.EhCacheFacade"><property name="cacheManager" ref="cacheManager" /></bean><!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 --><bean id="cachingAttributeSource"class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean><!-- 缓存拦截器:定义了缓存模块，ehcache只需要指定配置文件中的缓存名称 --><bean id="cachingInterceptor"class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor"><property name="cacheProviderFacade" ref="cacheProviderFacade" /><property name="cachingAttributeSource" ref="cachingAttributeSource" /><property name="cachingModels"><props><prop key="testCaching">cacheName=testCache</prop></props></property></bean><!-- 基于注解查找缓存业务方法的AOP通知器 --><bean id="cachingAttributeSourceAdvisor"class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor"><constructor-arg ref="cachingInterceptor" /></bean><!-- 基于注解查找触发缓存刷新动作的业务方法 --><bean id="flushingAttributeSource"class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean><!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存 --> <bean id="flushingInterceptor"class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor"><property name="cacheProviderFacade" ref="cacheProviderFacade" /><property name="flushingAttributeSource" ref="flushingAttributeSource" /><property name="flushingModels"><map><entry key="testFlushing"><beanclass="org.springmodules.cache.provider.ehcache.EhCacheFlushingModel"><property name="cacheNames"><list><value>testCache</value></list></property>  <!-- 报错，应该是不能直接设置cacheName <property name="cacheName" value="testCache"/> --></bean></entry></map></property></bean><!-- 基于注解查找刷新缓存业务方法的AOP通知器 --><bean id="flushingAttributeSourceAdvisor"class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor"><constructor-arg ref="flushingInterceptor" /></bean><!-- 测试对象 --><bean id="testCache" class="com.TestCache"/></beans>

 2）命名空间配置

Xml代码  

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>  

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ehcache="http://www.springmodules.org/schema/ehcache"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd"><!-- 这里可以不需要配置这个<bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" /> --><ehcache:config configLocation="classpath:ehcache.xml"id="cacheProvider" /><ehcache:annotations providerId="cacheProvider"><ehcache:caching cacheName="testCache" id="testCaching" /><ehcache:flushing cacheNames="testCache" id="testFlushing" /></ehcache:annotations><bean id="testCache" class="com.TestCache"/></beans>

 

 

OSCache：
1）普通配置

Xml代码  

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>  

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 这个是必须地，否则缓存不起作用 --><bean id="autoproxy"class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" /><!-- 缓存管理工厂：使用OSCache缓存管理,配置了OSCache使用的配置文件路径 --><bean id="cacheManager"class="org.springmodules.cache.provider.oscache.OsCacheManagerFactoryBean"><property name="configLocation" value="classpath:oscache.properties" /></bean><!-- 缓存提供：OSCache --><bean id="cacheProviderFacade" class="org.springmodules.cache.provider.oscache.OsCacheFacade"><property name="cacheManager" ref="cacheManager" /></bean><!-- 1.5+ Annotation 基于注解查找被缓存的业务方法 --><bean id="cachingAttributeSource"class="org.springmodules.cache.annotations.AnnotationCachingAttributeSource"></bean><!-- 缓存拦截器:定义了缓存模块，以及相应的刷新策略，以及缓存所属群组 --> <bean id="cachingInterceptor"class="org.springmodules.cache.interceptor.caching.MetadataCachingInterceptor"><property name="cacheProviderFacade" ref="cacheProviderFacade" /><property name="cachingAttributeSource" ref="cachingAttributeSource" /><property name="cachingModels"><props><prop key="testCaching">refreshPeriod=86400;cronExpression=0 1 * * *;groups=pb_test</prop></props></property></bean><!-- 基于注解查找缓存业务方法的AOP通知器 --><bean id="cachingAttributeSourceAdvisor"class="org.springmodules.cache.interceptor.caching.CachingAttributeSourceAdvisor"><constructor-arg ref="cachingInterceptor" /></bean><!-- 基于注解查找触发缓存刷新动作的业务方法 --><bean id="flushingAttributeSource"class="org.springmodules.cache.annotations.AnnotationFlushingAttributeSource"></bean><!-- 刷新拦截器：定义了刷新策略，基于那个模块ID，刷新相应的缓存群组 --><bean id="flushingInterceptor"class="org.springmodules.cache.interceptor.flush.MetadataFlushingInterceptor"><property name="cacheProviderFacade" ref="cacheProviderFacade" /><property name="flushingAttributeSource" ref="flushingAttributeSource" /><property name="flushingModels"><props><prop key="testFlushing">groups=pb_test</prop></props></property></bean><!-- 基于注解查找刷新缓存业务方法的AOP通知器 --><bean id="flushingAttributeSourceAdvisor"class="org.springmodules.cache.interceptor.flush.FlushingAttributeSourceAdvisor"><constructor-arg ref="flushingInterceptor" /></bean><bean id="testCache" class="com.TestCache"/></beans>

 
2)命名空间配置

Xml代码  

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>  

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:oscache="http://www.springmodules.org/schema/oscache"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springmodules.org/schema/oscache http://www.springmodules.org/schema/cache/springmodules-oscache.xsd"><!-- 这里可以不需要配置这个<bean id="autoproxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" /> --><oscache:config configLocation="classpath:oscache.properties" id="cacheProvider"/><oscache:annotations providerId="cacheProvider"><oscache:caching id="testCaching" groups="pb_test" cronExpression="0 1 * * *" refreshPeriod="86400"/><oscache:flushing id="testFlushing" groups="pb_test"/></oscache:annotations><bean id="testCache" class="com.TestCache"/></beans>

 

 

 

四.注解

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

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

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

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

五.测试

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

 

Java代码  

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. }  

/** COPYRIGHT Beijing NetQin-Tech Co.,Ltd.                                   ****************************************************************************** 源文件名: TestCache.java        * 功能: （描述文件功能）   * 版本:@version 1.0                                                                   * 编制日期: 2010-2-24       * 说明: （描述使用文件功能时的制约条件）                                       * 修改历史: (主要历史变动原因及说明)* YYYY-MM-DD |    Author      | Change Description      * 2010-2-24   |  hanqunfeng    |  Created */package com;import net.sf.ehcache.CacheManager;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springmodules.cache.annotations.CacheFlush;import org.springmodules.cache.annotations.Cacheable;import com.opensymphony.oscache.general.GeneralCacheAdministrator;public class TestCache {/**                                                           * 描述 : <描述函数实现的功能>. <br> *<p>                                                                                                                                                                                                                                                        * @param args                                                                                        */static String context = null;static ApplicationContext applicationContext;static{context = "applicationContext-ehcache.xml";//ehcache简单配置（命名空间）//context = "applicationContext-ehcache_full.xml";//ehcache完整配置//context = "applicationContext-oscache.xml";//oscache简单配置（命名空间）//context = "applicationContext-oscache_full.xml";//oscache完整配置applicationContext = new ClassPathXmlApplicationContext(context);}public static void main(String[] args) {    TestCache test = (TestCache)applicationContext.getBean("testCache");    System.out.println(test.getName(0));    System.out.println(test.getName(0));    System.out.println(test.getName(0));    test.flush();//    test.OSFlushAll();//    test.EHFlushAll();    System.out.println(test.getName(0));    System.out.println(test.getName(0));    System.out.println(test.getName(0));    }@Cacheable(modelId = "testCaching")public String getName(int i){System.out.println("Processing testCaching");return "nihao:"+i;}@CacheFlush(modelId = "testFlushing")public void flush(){System.out.println("Processing testFlushing");}/**                                                          * 描述 : <OSCache刷新全部缓存>. <br>*<p>                                                      问题：flushAll() 后不会再缓存数据                                                                                                                                                                                                                                                                                       */public void OSFlushAll(){GeneralCacheAdministrator cacheAdmin = (GeneralCacheAdministrator)applicationContext.getBean("cacheManager");cacheAdmin.flushAll();System.out.println("Processing OSFlushingAll");}/**                                                          * 描述 : <清空指定组名称的缓存>. <br>*<p>                                                                                                                                                                                                                                                       * @param groupName                                                                                       */public void OSFlushGroup(String groupName){GeneralCacheAdministrator cacheAdmin = (GeneralCacheAdministrator)applicationContext.getBean("cacheManager");cacheAdmin.flushGroup(groupName);//清除该组的缓存：pb_testSystem.out.println("Processing OSFlushingGroup:"+groupName);}/**                                                          * 描述 : <EHCache刷新全部缓存>. <br>*<p>                                                     success                                                                                                                                                                                                                                                                       */public void EHFlushAll(){CacheManager cacheAdmin = (CacheManager)applicationContext.getBean("cacheManager");cacheAdmin.clearAll();System.out.println("Processing EHFlushingAll");}/**                                                          * 描述 : <清空指定名称的缓存>. <br>*<p>                                                                                                                                                                                                                                                       * @param cacheName                                                                                       */public void EHFlushCache(String cacheName){CacheManager cacheAdmin = (CacheManager)applicationContext.getBean("cacheManager");cacheAdmin.getCache(cacheName).flush();//清除单个缓存:testCacheSystem.out.println("Processing EHFlushingCacheName:"+cacheName);}}

 测试结果

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

 

六.缓存配置文件

ehcache.xml

Xml代码  

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>  

<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"monitoring="autodetect"><diskStore path="java.io.tmpdir"/>    <defaultCache            maxElementsInMemory="10000"            eternal="false"            timeToIdleSeconds="120"            timeToLiveSeconds="120"            overflowToDisk="true"            maxElementsOnDisk="10000000"            diskPersistent="false"            diskExpiryThreadIntervalSeconds="120"            memoryStoreEvictionPolicy="LRU"            /> <cache name="testCache"           maxElementsInMemory="10000"           maxElementsOnDisk="1000"           eternal="false"           overflowToDisk="true"           diskSpoolBufferSizeMB="20"           timeToIdleSeconds="300"           timeToLiveSeconds="600"           memoryStoreEvictionPolicy="LFU"            /></ehcache>

 oscache.properties

Java代码  

1. cache.capacity=5000  

cache.capacity=5000

 

原文件请参见附件。

 

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

<bean id="communityService"
            class="org.springmodules.cache.interceptor.proxy.CacheProxyFactoryBean">
      <property name="cacheProviderFacade" ref="oscacheFacade" />
      <property name="cachingModels">
          <map>
              <entry key="loadCommunity">
                  <bean class="org.springmodules.cache.provider.oscache.OsCacheCachingModel">
                      <property name="refreshPeriod" value="3600" />
                      <property name="groups">
                          <list>
                              <value>communityinfo</value>
                          </list>
                      </property>
                  </bean>
              </entry>
          </map>
      </property>
      <property name="flushingModels">
          <map>
              <entry key="transferMastership">
                  <bean class="org.springmodules.cache.provider.oscache.OsCacheFlushingModel">
                      <property name="groups">
                          <list>
                              <value>communityuser</value>
                          </list>
                      </property>
                  </bean>
              </entry>
          </map>
      </property>
      <property name="target" ref="communityServiceProxy" />
    </bean>

主要是cachingModels、flushingModels和target，通过target指定目标，通过cachingModels指定目标bean中需要缓存的方法，可以为缓存entry指定自动刷新时间和缓存名字，flushingModels是指定在执行那些更新操作的时候会刷新缓存，指定方法名称和要刷新的缓存名称，另有些全局配置都通用没有必要描述。

spring model缓存的实现可以结合ehcache或者oscache都可以，配置方式可以是配置文件也可以是注解都非常灵活，这样就可脱离持久层框架，比如hibernate或则ibatis，当结合使用多种持久层处理方式的时候就显得耦合性得到了解放，最主要持久层可以处理刷新的缓存只是当前执行的实体模块，假如我更新一个人的积分的时候同时需要处理更新这个人的威望，那么结合spring model就可以通过管理业务层方法，对多个实体模块进行缓存管理，有效保证缓存触发多节点数据同步