`
hanqunfeng
  • 浏览: 1542229 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

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

Spring配置管理BeanAOPCache 
阅读更多

本文将构建一个普通工程来说明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 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 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 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 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函数的类来进行测试，代码如下：

 

/*
* 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 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

cache.capacity=5000

 

原文件请参见附件。

17
顶
1
踩
分享到：
| Spring2.5 MVC 处理管道使用参考手册V1.0 ...
评论
8 楼 gyxkg 2013-09-10  
好东西，非常感谢
7 楼 xiayh04 2013-08-05  
spring 3以后无法使用：
java.lang.NoClassDefFoundError: org/springframework/metadata/Attributes
6 楼 h248980496 2013-01-30  
非常好的例子，懂的人自然懂
5 楼 蓝色飞扬 2011-03-12  
楼主，问下，这个例子我部署到tomcat之后flush刷新缓存不起作用了，你知道怎么回事吧？
4 楼 蓝色飞扬 2011-03-10  
例子非常详细，学些了，谢谢！ 
3 楼 JetMah 2010-10-31  
如果是ehcache的话建议使用http://code.google.com/p/ehcache-spring-annotations，这个也是ehcache官方推荐的与spring3在一起的方式：http://ehcache.org/recipes/spring-annotations.html
2 楼 javaliver 2010-08-26  
Lz 如果缓存内容的数据  数据库中发生了变化,是不是通过刷新缓存的方式,重新加载呢(这样的话数据库的数据要重新放到缓存内) ？
怎么只更新缓存内变化的数据呢?
1 楼 wpfwupengfeiwpf 2010-06-25  
springmodules好象到spring3.0不怎么支持了
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    点智数码--注释驱动的-Spring-cache-缓存的介绍.doc

    Spring Cache 是 Spring 框架从 3.1 版本开始引入的一种注解驱动的缓存抽象，它提供了一种简单而灵活的方式来在应用程序中实现缓存功能，无需依赖特定的缓存实现，如 EhCache 或 OSCache。Spring Cache 的核心特性...

    缓存说明.doc

    此外，ehcache能很好地与Spring框架集成，通过Spring的AOP（面向切面编程）可以方便地实现缓存注解，简化了缓存管理。例如，可以使用`@Cacheable`注解标记方法，使得该方法的返回结果被缓存。 **oscache** oscache...

    Spring cache

    Spring Cache 是 Spring 3.1 版本引入的一项重要特性，它不是一种具体的缓存实现（如 EHCache 或 OSCache），而是一种缓存使用的抽象层。通过在现有的业务代码上添加特定的注解，可以轻松地为方法调用添加缓存支持。...

    Hibernate教程25_Hibernate缓存

    **压缩包子文件的文件名称列表：** "s2sh_relation24_3KindsOf_Cache" 这个文件名暗示了可能是一个基于Struts2、Spring和Hibernate（简称S2SH）的项目，其中包含了关于三种类型的缓存的示例。这三种缓存可能指的是...

    Struts+spring+hibernate面试资料

    常见的第三方二级缓存插件有EHCache、OSCache等。 **缓存的范围** 包括事务范围、进程范围和集群范围。不同的范围适用于不同的应用场景，可以根据项目的实际需求选择合适的缓存策略。 - **事务范围**：每个事务有...

    java8-spring5部分技术与工具介绍.pdf

    Spring Framework 3.1引入了一个新的特性——基于注解的缓存管理。这个特性使得开发者可以在不修改业务逻辑的情况下轻松地添加缓存支持。 #### 特点 - **抽象层**：Spring Cache提供了一个抽象层，允许开发者使用...

    Spring,hibernate,struts的面试笔试题.doc

    - **第三方缓存实现：** 如 Ehcache、OSCache 等，适用于更复杂的缓存需求。 **使用条件：** - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被频繁访问。 - 非关键性数据...

    Spring_Structs_Hibernate

    - 第三方缓存实现：如EHCache、OSCache等。 #### 5. Hibernate 查询方式 - **SQL 查询：** 直接使用SQL语句进行查询。 - **Criteria API：** 提供了一种面向对象的方式来构建查询。 - **HQL（Hibernate Query ...

    struts、spring、hibernate工作原理.

    可以使用内置的缓存实现，也可以集成第三方缓存实现（如EHCache、OSCache等）。 - **延迟加载**：Hibernate支持延迟加载策略，只有在真正需要数据时才会加载，从而减少内存占用和提高性能。 - **类之间的关系实现**...

    struts+spring+hibernate笔试面试常见问题

    - **第三方缓存**：如 EhCache、OSCache 等。 #### 六、Hibernate 查询方式 **6.1 SQL 查询** 直接编写 SQL 语句进行查询。 **6.2 HQL 查询** - **属性查询**：针对实体类的属性进行查询。 - **参数查询**：使用...

    Spring 常见面试题

    - **第三方缓存实现**：如 Ehcache、OSCache 等。 #### 使用条件 - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被系统频繁使用。 - 对于非关键数据，使用缓存可以提高...

    Spring,hibernate,struts的面试笔试题含答案

    - **第三方缓存实现：** 使用如 Ehcache、OSCache 等第三方库提供的缓存服务。 **使用二级缓存的条件：** - 数据不会被第三方修改。 - 数据大小在可接受范围内。 - 数据更新频率较低。 - 同一数据被系统频繁使用...

    jeefuseMDA用户开发手册1

    通过配置文件或注解，Spring可以自动装配bean，实现灵活的依赖注入。 3. Web MVC框架： Struts2 和 Spring MVC 是两种广泛使用的MVC（Model-View-Controller）框架，用于处理Web应用的业务逻辑。Struts2提供了一...

    hibernate 3.2.6架包（包括所有jar，eg，api）

    此外，还支持第三方缓存解决方案，如Ehcache和 OSCache。 5. API文档：在压缩包中的“doc”文件夹，应该包含了详细的API文档，帮助开发者理解并使用Hibernate的各种接口和类。这些文档通常包含方法描述、参数说明和...

    hibernate3.6所有包

    5. **缓存支持**：Hibernate提供了二级缓存机制，通过第三方缓存提供者如Ehcache（`ehcache-core.jar`）或OSCache（`oscache.jar`）提高性能。这些缓存库使得数据能够在内存中被快速访问，减少对数据库的直接访问。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics