`
newleague
  • 浏览: 1499534 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类

Spring中AOP实现EHCache的整合中采用SpringModule结合(二)

 
阅读更多

 在Spring中通过EHCache实现缓存,必须手动缓存或者通过AOP进行缓存实现。通过采用SpringModules进行缓存是EHCache不必进行自动缓存,由SpringMoudles提供拦截器实现,简化开发的。实现如下:

1.EHCache的配置如下:

Java代码 复制代码 收藏代码
  1. <ehcache>   
  2.      <diskStore path="java.io.tmpdir" />   
  3.      <defaultCache maxElementsInMemory="10000" eternal="false"  
  4.          timeToIdleSeconds="2" timeToLiveSeconds="5" overflowToDisk="true"  
  5.          maxElementsOnDisk="10000000" diskPersistent="false"  
  6.          diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU" />   
  7.      <cache name="testCache" maxElementsInMemory="10000"  
  8.          maxElementsOnDisk="1000" eternal="false" overflowToDisk="false"  
  9.          diskSpoolBufferSizeMB="20" timeToIdleSeconds="60" timeToLiveSeconds="3600"  
  10.         memoryStoreEvictionPolicy="LFU" />   
  11. </ehcache>  
<ehcache>
     <diskStore path="java.io.tmpdir" />
     <defaultCache maxElementsInMemory="10000" eternal="false"
         timeToIdleSeconds="2" timeToLiveSeconds="5" overflowToDisk="true"
         maxElementsOnDisk="10000000" diskPersistent="false"
         diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU" />
     <cache name="testCache" maxElementsInMemory="10000"
         maxElementsOnDisk="1000" eternal="false" overflowToDisk="false"
         diskSpoolBufferSizeMB="20" timeToIdleSeconds="60" timeToLiveSeconds="3600"
        memoryStoreEvictionPolicy="LFU" />
</ehcache>

 

2.Spring中配置如下

Java代码 复制代码 收藏代码
  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 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">   
  5.      
  6.       <!-- Using a EHCache cache manager -->   
  7.       <bean id="cacheManager"  
  8.           class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">   
  9.           <!--EHCache cacheManager    
  10.             <property name="cacheManagerName" value="mainCache"/>   
  11.           -->   
  12.          <property name="configLocation" value="classpath:ehcache.xml" />   
  13.      </bean>   
  14.     
  15.      <!-- 使用Spring Modules对 EhCache的封装  -->   
  16.      <bean id="cacheProviderFacade" class="<SPAN style="COLOR: #ff0000">org.springmodules.cache.provider.ehcache.EhCacheFacade</SPAN>">   
  17.          <property name="cacheManager" ref="cacheManager" />   
  18.      </bean>   
  19.         
  20.      <!-- 配置 方法 拦截器  -->   
  21.      <!-- 缓存拦截器 -->   
  22.      <bean id="cachingInterceptor"  
  23.          class="<SPAN style="COLOR: #ff0000">org.springmodules.cache.interceptor.caching.MethodMapCachingInterceptor</SPAN>">   
  24.          <property name="cacheProviderFacade" ref="cacheProviderFacade" />   
  25.          <property name="cachingModels">   
  26.           <!-- 进行cache缓存 -->   
  27.              <props>    
  28.                 <!-- 所有TicketService对象中,以get开头的方法都将进行缓存 -->   
  29.                  <prop key="com.easyway.ecache.service.TicketService.get*">cacheName=testCache</prop>   
  30.              </props>   
  31.          </property>   
  32.      </bean>   
  33.         
  34.      <!-- 缓存刷新拦截器 -->   
  35.      <bean id="flushingInterceptor"  
  36.          class="<SPAN style="COLOR: #99cc00">org.springmodules.cache.interceptor.flush.MethodMapFlushingInterceptor</SPAN>">   
  37.          <property name="cacheProviderFacade" ref="cacheProviderFacade" />   
  38.          <property name="flushingModels">   
  39.          <!-- 进行cache刷新(清除) -->   
  40.              <props>   
  41.                  <prop key="com.easyway.ecache.service.TicketService.set*">cacheNames=testCache</prop>   
  42.              </props>   
  43.          </property>   
  44.      </bean>   
  45.         
  46.      <!-- 相关的服务 -->   
  47.      <bean id="ticketService" class="com.easyway.ecache.service.TicketService"></bean>   
  48.         
  49.      <!-- 配置 基于BeanName规则的动态代理封装 -->   
  50.      <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
  51.          <!-- 设置拦截的bean名称 -->   
  52.          <property name="beanNames">   
  53.              <list>   
  54.                  <value>ticketService</value>   
  55.              </list>   
  56.          </property>   
  57.          <!-- 设置拦截器的名称 -->   
  58.          <property name="interceptorNames">   
  59.              <list>   
  60.                  <value>cachingInterceptor</value>   
  61.                  <value>flushingInterceptor</value>   
  62.              </list>   
  63.          </property>   
  64.      </bean>   
  65.  </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-2.5.xsd">
  
      <!-- Using a EHCache cache manager -->
      <bean id="cacheManager"
          class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
          <!--EHCache cacheManager 
            <property name="cacheManagerName" value="mainCache"/>
          -->
         <property name="configLocation" value="classpath:ehcache.xml" />
     </bean>
 
     <!-- 使用Spring Modules对 EhCache的封装  -->
     <bean id="cacheProviderFacade" class="org.springmodules.cache.provider.ehcache.EhCacheFacade">
         <property name="cacheManager" ref="cacheManager" />
     </bean>
     
     <!-- 配置 方法 拦截器  -->
     <!-- 缓存拦截器 -->
     <bean id="cachingInterceptor"
         class="org.springmodules.cache.interceptor.caching.MethodMapCachingInterceptor">
         <property name="cacheProviderFacade" ref="cacheProviderFacade" />
         <property name="cachingModels">
          <!-- 进行cache缓存 -->
             <props> 
                <!-- 所有TicketService对象中,以get开头的方法都将进行缓存 -->
                 <prop key="com.easyway.ecache.service.TicketService.get*">cacheName=testCache</prop>
             </props>
         </property>
     </bean>
     
     <!-- 缓存刷新拦截器 -->
     <bean id="flushingInterceptor"
         class="org.springmodules.cache.interceptor.flush.MethodMapFlushingInterceptor">
         <property name="cacheProviderFacade" ref="cacheProviderFacade" />
         <property name="flushingModels">
         <!-- 进行cache刷新(清除) -->
             <props>
                 <prop key="com.easyway.ecache.service.TicketService.set*">cacheNames=testCache</prop>
             </props>
         </property>
     </bean>
     
     <!-- 相关的服务 -->
     <bean id="ticketService" class="com.easyway.ecache.service.TicketService"></bean>
     
     <!-- 配置 基于BeanName规则的动态代理封装 -->
     <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
         <!-- 设置拦截的bean名称 -->
         <property name="beanNames">
             <list>
                 <value>ticketService</value>
             </list>
         </property>
         <!-- 设置拦截器的名称 -->
         <property name="interceptorNames">
             <list>
                 <value>cachingInterceptor</value>
                 <value>flushingInterceptor</value>
             </list>
         </property>
     </bean>
 </beans>

 仔细观察可知道上面带颜色的类其实是几个采用AOP实现的拦截器而已。

3.编写测试服务类

Java代码 复制代码 收藏代码
  1. package com.easyway.ecache.service;   
  2.   
  3. import java.util.List;   
  4. /**  
  5.  * 对其所有的以get* 方式命令的方法,进行缓存处理。当调用set* 命令时,需要其删除缓存  
  6.  * @author longgangbai  
  7.  *  
  8.  */  
  9. @SuppressWarnings("unchecked")   
  10. public class TicketService {   
  11.        
  12.     /**  
  13.      * 需要缓存的集合  
  14.      */  
  15.     private List ticketList;   
  16.     /**  
  17.      * 需要缓存的服务名称  
  18.      */  
  19.     private String serviceName;   
  20.   
  21.     public String getServiceName() {   
  22.         return serviceName;   
  23.     }   
  24.   
  25.     public void setServiceName(String serviceName) {   
  26.         this.serviceName = serviceName;   
  27.     }   
  28.   
  29.     public List getTicketList() {   
  30.         return ticketList;   
  31.     }   
  32.     public void setTicketList(List ticketList) {   
  33.         this.ticketList = ticketList;   
  34.     }   
  35.     /**  
  36.      * 修改的服务端名称备注但是不缓存  
  37.      * @param serviceName  
  38.      */  
  39.     public void changesetServiceName(String serviceName) {   
  40.         this.serviceName = serviceName;   
  41.     }   
  42. }  
package com.easyway.ecache.service;

import java.util.List;
/**
 * 对其所有的以get* 方式命令的方法,进行缓存处理。当调用set* 命令时,需要其删除缓存
 * @author longgangbai
 *
 */
@SuppressWarnings("unchecked")
public class TicketService {
	
	/**
	 * 需要缓存的集合
	 */
	private List ticketList;
	/**
	 * 需要缓存的服务名称
	 */
	private String serviceName;

	public String getServiceName() {
		return serviceName;
	}

	public void setServiceName(String serviceName) {
		this.serviceName = serviceName;
	}

	public List getTicketList() {
		return ticketList;
	}
	public void setTicketList(List ticketList) {
		this.ticketList = ticketList;
	}
	/**
	 * 修改的服务端名称备注但是不缓存
	 * @param serviceName
	 */
	public void changesetServiceName(String serviceName) {
		this.serviceName = serviceName;
	}
}

 

 

 

4.测试用例如下

Java代码 复制代码 收藏代码
  1. package com.easyway.ecache.service;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5. /**  
  6.  * 测试SpringModule EhCache 的整合的应用  
  7.  * @author longgangbai  
  8.  *  
  9.  */  
  10. public class Test {   
  11. public static void main(String[] args) {   
  12.        
  13.     ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath*:applicationContext.xml");   
  14.        
  15.     TicketService  ticketSrv=(TicketService)ctx.getBean("ticketService");   
  16.        
  17.     String srvName0=ticketSrv.getServiceName();   
  18.     //获取初始化服务端名称   
  19.     System.out.println("srvName0="+srvName0);   
  20.     //设置存储的名称   
  21.     ticketSrv.setServiceName("ticketService");   
  22.     srvName0=ticketSrv.getServiceName();   
  23.     //获取服务端名称   
  24.     System.out.println("srvName1="+srvName0);   
  25.        
  26.     //修改服务名称但是不缓存   
  27.     ticketSrv.changesetServiceName("serviceName");   
  28.        
  29.     srvName0=ticketSrv.getServiceName();   
  30.     //获取服务端名称来源自缓存注意观察   
  31.    System.out.println("srvName2="+srvName0);   
  32.    //   
  33.    //srvName0=null   
  34.    //srvName1=ticketService   
  35.    //srvName2=ticketService   
  36.       
  37.        
  38. }   
  39. }  
package com.easyway.ecache.service;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 测试SpringModule EhCache 的整合的应用
 * @author longgangbai
 *
 */
public class Test {
public static void main(String[] args) {
	
	ApplicationContext ctx=new ClassPathXmlApplicationContext("classpath*:applicationContext.xml");
	
	TicketService  ticketSrv=(TicketService)ctx.getBean("ticketService");
	
	String srvName0=ticketSrv.getServiceName();
	//获取初始化服务端名称
	System.out.println("srvName0="+srvName0);
	//设置存储的名称
	ticketSrv.setServiceName("ticketService");
    srvName0=ticketSrv.getServiceName();
	//获取服务端名称
	System.out.println("srvName1="+srvName0);
	
	//修改服务名称但是不缓存
	ticketSrv.changesetServiceName("serviceName");
	
	srvName0=ticketSrv.getServiceName();
	//获取服务端名称来源自缓存注意观察
   System.out.println("srvName2="+srvName0);
   //
   //srvName0=null
   //srvName1=ticketService
   //srvName2=ticketService
   
	
}
}

 

 

 

5.测试结果如下:

srvName0=null
srvName1=ticketService
srvName2=ticketService

 

6.采用的类库如下:

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
 <classpathentry kind="src" path="src"/>
 <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
 <classpathentry kind="lib" path="src/spring.jar"/>
 <classpathentry kind="lib" path="src/spring-modules-cache.jar"/>
 <classpathentry kind="lib" path="src/ehcache-1.6.0-beta4.jar"/>
 <classpathentry kind="lib" path="src/commons-lang.jar"/>
 <classpathentry kind="lib" path="src/commons-logging.jar"/>
 <classpathentry kind="lib" path="src/oro-2.0.7.jar"/>
 <classpathentry kind="lib" path="src/cglib-nodep-2.1_3.jar"/>
 <classpathentry kind="output" path="bin"/>
</classpath>

分享到:
评论

相关推荐

    Spring中AOP实现EHCache的整合(一)

    在Spring中,AOP是通过定义切面(Aspect)和通知(Advice)来实现的,切面定义了关注点的逻辑结构,而通知则定义了何时、何地以及如何执行这些逻辑。 接下来,我们引入EHCache。EHCache支持本地内存缓存、分布式...

    SpringAOP结合ehCache实现简单缓存实例

    本文将深入探讨如何结合Spring AOP与EhCache实现一个简单的缓存实例,以便优化Java应用的运行效率。 首先,让我们了解Spring AOP。Spring AOP是Spring框架的一部分,它允许我们在不修改业务代码的情况下,通过定义...

    Spring AOP+ehCache简单缓存系统解决方案

    为了在Spring中使用ehCache,我们需要添加相应的依赖,并配置Spring AOP以拦截需要缓存的方法。在Spring的配置文件中,我们可以使用`&lt;aop:config&gt;`和`&lt;cache:annotation-driven&gt;`标签来启用AOP和缓存注解支持。然后...

    Spring+Hibernate+ehcache整合

    在"Spring+Hibernate+ehcache整合"项目中,开发者已经完成了一个将这三个框架集成的基础工程。虽然Struts没有被明确提及,但通常在Web开发中,Spring与Struts结合可以构建更完整的MVC架构。这个整合项目可能包含以下...

    spring-aop.jar各个版本

    spring-aop-1.1.1.jar spring-aop-1.2.6.jar spring-aop-1.2.9.jar spring-aop-2.0.2.jar spring-aop-2.0.6.jar spring-aop-2.0.7.jar spring-aop-2.0.8.jar spring-aop-2.0.jar spring-aop-2.5.1.jar spring-aop-...

    Spring AOP+ehCache简单缓存系统解决方案.doc

    Spring AOP 和 EhCache 结合使用提供了一个简单而有效的缓存解决方案,主要目的是优化系统性能,减少对数据库的频繁访问。下面将详细解释这个解决方案的关键组成部分。 首先,EhCache 是一个广泛使用的开源 Java ...

    spring+ibatis+ehcache整合例子

    在Spring中,Ehcache可以被集成为一个缓存提供者,通过@Cacheable、@CacheEvict等注解实现方法级别的缓存控制。这有助于提升查询效率,尤其是在处理大数据量时。 **整合过程** 1. **配置Spring** 首先,我们需要...

    spring struts2 hibernate ehcache整合

    这篇博客“spring struts2 hibernate ehcache整合”显然探讨了如何将这四个组件集成到同一个项目中,以提升应用程序的性能和效率。以下是关于这些技术及其整合的关键知识点的详细说明: 1. **Spring框架**:Spring...

    开发工具 spring-aop-4.3.6.RELEASE

    开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...

    spring-aop-jar

    在IT领域,Spring框架是一个广泛使用的Java应用框架,它提供了许多...在实际项目中,结合aopalliance.jar、spring-aop-4.1.6.RELEASE.jar和spring-aspects-4.1.6.RELEASE.jar,我们可以构建出高效且易于管理的系统。

    spring-aop-5.2.0.RELEASE-API文档-中文版.zip

    赠送jar包:spring-aop-5.2.0.RELEASE.jar; 赠送原API文档:spring-aop-5.2.0.RELEASE-javadoc.jar; 赠送源代码:spring-aop-5.2.0.RELEASE-sources.jar; 赠送Maven依赖信息文件:spring-aop-5.2.0.RELEASE.pom;...

    spring3 hibernate4 ehcache实例

    本文将详细介绍如何在Spring3和Hibernate4环境下整合Ehcache,实现数据缓存功能,以提高应用性能。 1. **Spring3与Hibernate4整合** 在Spring3中配置Hibernate4,我们需要在配置文件中定义SessionFactory,并使用...

    基于注解实现SpringAop

    基于注解实现SpringAop基于注解实现SpringAop基于注解实现SpringAop

    SpringMVC+Mybatis+Spring+Shiro+ehcache整合配置文件

    SpringMVC、Mybatis、Spring、Shiro和Ehcache这五个技术组件是Java Web开发中的关键工具,它们各自承担着不同的职责,并通过整合来实现强大的功能。下面将详细阐述这些技术以及它们在整合中的作用。 首先,...

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...

    spring基于AOP实现事务

    在Spring中,AOP主要是通过代理模式实现的,有JDK动态代理和CGLIB两种方式。 对于Spring事务管理,我们通常有两种方式:编程式和声明式。编程式事务管理需要在代码中显式地调用begin、commit、rollback等事务控制...

    spring aop实现原理

    NULL 博文链接:https://zhang-yingjie-qq-com.iteye.com/blog/319927

    spring的aop实现

    在Spring中,这些关注点被封装为“切面”(Aspect),并在运行时通过“通知”(Advice)动态地插入到目标对象的方法执行流程中。通知有五种类型:前置通知(Before)、后置通知(After)、返回后通知(After ...

Global site tag (gtag.js) - Google Analytics