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">
					<bean
						class="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.xsd
			http://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.xsd
			http://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_test
		System.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();//清除单个缓存:testCache	
		System.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 

 

原文： http://hanqunfeng.iteye.com/blog/603719/

cache.capacity=5000