注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

和申的个人主页

专注于java开发,1985wanggang

 
 
 

日志

 
 

利用Spring IoC和EHCache 拦截缓存方法,缓存结果  

2010-12-03 11:21:58|  分类: java缓存 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
EHCache作为一种通用缓存解决方案集成进 Spring。

我将示范拦截器的例子,它能把方法返回的结果缓存起来。

利用 Spring IoC 配置 EHCache

Spring 里配置 EHCache 很简单。你只需一个 ehcache.xml 文件,该文件用于配置 EHCache

拦截器将使用 constantSeviceCache区域缓存方法返回结果。下面利用 Spring IoC 让 bean 来访问这一区域。

可以灵活的根据缓存的时间来建立多个这样的缓存,来控制不同的缓存时间

构建我们的 MethodCacheInterceptor

该拦截器根据spring2.0规范。一旦运行起来(kicks-in),它首先检查被拦截方法是否被配置为可缓存的。这将可选择性的配置想要缓存的 bean 方法。只要调用的方法配置为可缓存,拦截器将为该方法生成 cache key 并检查该方法返回的结果是否已缓存。如果已缓存,就返回缓存的结果,否则再次调用被拦截方法,并缓存结果供下次调用。

com.heshen.cache.MethodCacheInterceptor

MethodCacheInterceptor 代码说明了:

  • 默认条件下,所有方法返回结果都被缓存了(methodNames 是 null)
  • 缓存区利用 IoC 形成
  • cacheKey 的生成还包括方法参数的因素(译注:参数的改变会影响 cacheKey)

使用 MethodCacheInterceptor

下面摘录了怎样配置 MethodCacheInterceptor

译注

夏昕所著《Hibernate 开发指南》,其中他这样描述 EHCache 配置文件的:

ehcache.xml 文件

<ehcache>
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
        maxElementsInMemory="10000" //Cache中最大允许保存的数据数量
        eternal="false"                       //Cache中数据是否为常量
        timeToIdleSeconds="120"     //缓存数据钝化时间
        timeToLiveSeconds="120"     //缓存数据的生存时间
        overflowToDisk="true"       //内存不足时,是否启用磁盘缓存
    />
</ehcache>
<cache name="constantSeviceCache
"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="3600"
        timeToLiveSeconds="3600"
        overflowToDisk="true"
        />

提供缓存拦截的类
 MethodCacheInterceptor.java

/**
*/
package com.heshen.cache;

import java.io.Serializable;
import java.lang.reflect.Method;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

/**
 * 针对方法切入,进行缓存的拦截器
 * @author wanggang
   @version 2010-12-03
 *
 *       缓存处理
 */
public class
MethodCacheInterceptor implements InitializingBean {

    private Logger logger = Logger.getLogger("Method-Cache-Inegceptor");

    private Cache serviceCache;

    /**
     * 设置缓存名
     */
    public void setServiceCache(Cache serviceCache) {
        this.serviceCache = serviceCache;
    }

    /**
     * 主方法 如果某方法可被缓存就缓存其结果 方法结果必须是可序列化的(serializable)
     */
    public Object doCacheOperation(ProceedingJoinPoint pjp)
            throws Throwable {

        String targetName = pjp.getTarget().getClass().getName();
        Signature signature = pjp.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        // String methodName = pjp.getThis()methodName.
        // invocation.getMethod().getName();
        String methodName = method.getName();

        Object[] arguments = pjp.getArgs();// invocation.getArguments();
        Object result;
        // logger.info("looking for method result in cache");
        String cacheKey = getCacheKey(targetName, methodName, arguments);
        logger.info("cache key" + cacheKey);
        Element element = serviceCache.get(cacheKey);
        if (element == null) {
            // call target/sub-interceptor
            logger.info("calling intercepted method");
            result = pjp.proceed();

            // cache method result
            logger.info("caching result");
            element = new Element(cacheKey, (Serializable) result);
            serviceCache.put(element);
        }
        return element.getValue();

    }

    /**
     * creates cache key: targetName.methodName.argument0.argument1...
     */
    private String getCacheKey(String targetName, String methodName,
            Object[] arguments) throws Exception {
        StringBuffer sb = new StringBuffer();
        sb.append(targetName).append(".").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sb.append(".").append(arguments[i]);
            }
        }
        return sb.toString();
    }
   
    /**
     * 检查是否提供必要参数。
     */
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(serviceCache,
                "A cache is required. Use setCache(Cache) to provide one.");
    }


}
 
 
 cacheInterceptor.xml缓存拦截器配置文件

<?xml version="1.0" encoding="GBK"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
    default-autowire="byName">
   
    <!-- 实际提供缓存服务的类 -->
   <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"/>
    <!-- 缓存不会变动的服务  -->
   <bean id="constantSeviceCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">  
        <property name="cacheManager">
            <ref bean="cacheManager"/> 
        </property>  
        <property name="cacheName">  
            <value>constantSeviceCache</value>
        </property>  
    </bean>

 
    <!-- 缓存不会变动的服务  -->
    <bean id="constantSeviceCacheMethodCacheInterceptor" class="com.
heshen.cache.MethodCacheInterceptor">
         <property name="serviceCache">  
            <ref local="constantSeviceCache" />  
        </property>  
    </bean>
   
   
    <!--  缓存不会变动的服务 -->
<aop:config>
      <aop:aspect id="constantSeviceCacheOperation" ref="constantSeviceCacheMethodCacheInterceptor">
        <aop:pointcut id="
test1ConstantSeviceCacheCut" expression="execution(* com.heshen.service.impl.Test1ServiceImpl.*(..))"/>
        <aop:pointcut id="
test2ClassServiceCacheCut" expression="execution(* com.heshen.service.impl.Test2ServiceImpl.*(..))"/>
               
        <aop:around pointcut-ref="
test1ConstantSeviceCacheCut" method="doCacheOperation"/>        
        <aop:around pointcut-ref="
test2ClassServiceCacheCut" method="doCacheOperation"/>
      </aop:aspect>
    </aop:config>

    <!--  还可以继续配置其他的缓存切面 -->
<!--
<aop:config>
      <aop:aspect id="constantSeviceCacheOperation" ref="constantSeviceCacheMethodCacheInterceptor">
        <aop:pointcut id="test1ConstantSeviceCacheCut" expression="execution(* com.
heshen.service.impl.Test1ServiceImpl.*(..))"/>
        <aop:pointcut id="
test2ClassServiceCacheCut" expression="execution(* com.heshen.service.impl.Test2ServiceImpl.*(..))"/>
               
        <aop:around pointcut-ref="
test1ConstantSeviceCacheCut" method="doCacheOperation"/>        
        <aop:around pointcut-ref="
test2ClassServiceCacheCut" method="doCacheOperation"/>
      </aop:aspect>
    </aop:config>
-->
</beans>

 

cacheInterceptor.xml缓存拦截器配置文件

/**
*/
com.heshen.service.impl;


/**
 * 具体的service类
 * @author wanggang
   @version 2010-12-03
 *
 *       缓存处理
 */
public class
Test2ServiceImpl implements test2Service {

    private Logger logger = Logger.getLogger("
Test2ServiceImpl ");

    public void doSomeThing1(String a){
    }

   public String doSomeThing2(String arg1,String arg2){
    }

   ....
}


 
  评论这张
 
阅读(1485)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017