ehcache

ssydxa219

浏览: 633113 次
性别:
来自: 杭州

最近访客更多访客>>

jmi_hua

依然任逍遥

gaojingsong

jveqi

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

ehcache

package com.ge.energy.confirm.cache;

import java.lang.reflect.Method;
import java.util.List;
import net.sf.ehcache.Cache;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class EhCacheAfterAdvice implements AfterReturningAdvice,
InitializingBean {
private static final Log logger = LogFactory
.getLog(EhCacheAfterAdvice.class);

private Cache cache;

public void setCache(Cache cache) {
this.cache = cache;
}

public EhCacheAfterAdvice() {
super();
}

public void afterReturning(Object arg0, Method arg1, Object[] arg2,
   Object arg3) throws Throwable {
  String className = arg3.getClass().getName();
  @SuppressWarnings("rawtypes")
  List list = cache.getKeys();
  for (int i = 0; i < list.size(); i++) {
   String cacheKey = String.valueOf(list.get(i));
   if (cacheKey.startsWith(className)) {
    cache.remove(cacheKey);
    logger.debug("remove cache " + cacheKey);
   }
  }
}

public void afterPropertiesSet() throws Exception {
Assert.notNull(cache,
"Need a cache. Please use setCache(Cache) create it.");
}

}
-------------------------------------------------------------------

package com.ge.energy.confirm.cache;

import java.io.Serializable;

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

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

public class EhCacheInterceptor implements MethodInterceptor, InitializingBean {
private static final Log logger = LogFactory
.getLog(EhCacheInterceptor.class);

private Cache cache;

public void setCache(Cache cache) {
this.cache = cache;
}

public EhCacheInterceptor() {
super();
}

/**
* Interceptor service .*find*.*，the result is or not exit，
* if it is exitting return the cache result， otherwire，connect db ,
* get dataset，& put the dataset into cache
*/
public Object invoke(MethodInvocation invocation) throws Throwable {
  String targetName = invocation.getThis().getClass().getName();
  String methodName = invocation.getMethod().getName();
  Object[] arguments = invocation.getArguments();
  Object result;

logger.debug("Find object from cache is " + cache.getName());

String cacheKey = getCacheKey(targetName, methodName, arguments);
Element element = cache.get(cacheKey);

  if (element == null) {
   logger.debug("Hold up method , Get method result and create cache........!");
   result = invocation.proceed();
   element = new Element(cacheKey, (Serializable)result);
   cache.put(element);
  }
  return element.getValue();
}

/**
* get cache key method，cache key is the one Cache of Element unqire id, cache key is
* package+className+methodName，eg:com.ge.energy.confirm.service.BucketizationService.findModelsBySSOID(str)
*/
private String getCacheKey(String targetName, String methodName,
   Object[] arguments) {
  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();
}

/**
* implement InitializingBean，check cache or not null
*/
public void afterPropertiesSet() throws Exception {
Assert.notNull(cache,
"Need a cache. Please use setCache(Cache) create it.");
}

}
--------------------------------------------------------------------------

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />
<cache name="pgs_cache"
        maxElementsInMemory="100000"
        eternal="false"
        timeToIdleSeconds="300000"
        timeToLiveSeconds="600000"
        overflowToDisk="true"
        />
</ehcache>
-----------------------------------------------------

<bean id="defaultCacheManager"
  class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
  <property name="configLocation">
   <value>classpath:ehcache.xml</value>
  </property>
</bean>

<bean id="ehCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  <property name="cacheManager">
   <ref bean="defaultCacheManager" />
  </property>
  <property name="cacheName">
   <value>pgs_cache</value>
  </property>
</bean>

<bean id="ehCacheInterceptor" class="com.ge.energy.confirm.cache.EhCacheInterceptor">
  <property name="cache">
   <ref bean="ehCache" />
  </property>
</bean>

<bean id="ehCacheAfterAdvice" class="com.ge.energy.confirm.cache.EhCacheAfterAdvice">
  <property name="cache">
   <ref bean="ehCache" />
  </property>
</bean>

<bean id="ehCachePointCut"
  class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  <property name="advice">
   <ref bean="ehCacheInterceptor" />
  </property>
  <property name="patterns">
   <list>
    <value>.*find*.*</value>
   </list>
  </property>
</bean>

<bean id="ehCachePointCutAdvice"
  class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  <property name="advice">
   <ref bean="ehCacheAfterAdvice" />
  </property>
  <property name="patterns">
   <list>
    <value>.*save*.*</value>
    <value>.*update*.*</value>
    <value>.*delete*.*</value>
   </list>
  </property>
</bean>

<bean id="bucketizationServiceCache" class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="target">
   <ref bean="bucketizationService"></ref>
  </property>

  <property name="interceptorNames">
   <list>
     <value>ehCachePointCut</value>
           <value>ehCachePointCutAdvice</value>
   </list>
  </property>
</bean>

/////////////////////////////////////////////////

利用 Spring IoC 配置 EHCache

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

<!—设置缓存文件 .data 的创建路径。

如果该路径是 Java 系统参数，当前虚拟机会重新赋值。

下面的参数这样解释：

user.home – 用户主目录

user.dir – 用户当前工作目录

java.io.tmpdir – 默认临时文件路径 -->

<!—缺省缓存配置。CacheManager 会把这些配置应用到程序中。

下列属性是 defaultCache 必须的：

maxInMemory - 设定内存中创建对象的最大值。

eternal - 设置元素（译注：内存中对象）是否永久驻留。如果是，将忽略超

时限制且元素永不消亡。

timeToIdleSeconds - 设置某个元素消亡前的停顿时间。

也就是在一个元素消亡之前，两次访问时间的最大时间间隔值。

这只能在元素不是永久驻留时有效（译注：如果对象永恒不灭，则

设置该属性也无用）。

如果该值是 0 就意味着元素可以停顿无穷长的时间。

timeToLiveSeconds - 为元素设置消亡前的生存时间。

也就是一个元素从构建到消亡的最大时间间隔值。

这只能在元素不是永久驻留时有效。

overflowToDisk - 设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘

上。

-->

<cache name="org.taha.cache.METHOD_CACHE"

maxElementsInMemory="300"

eternal="false"

timeToIdleSeconds="500"

timeToLiveSeconds="500"

overflowToDisk="true"

</ehcache>

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

<value>classpath:ehcache.xml</value>

</property>

</bean>

</property>

<value>org.taha.cache.METHOD_CACHE</value>

</property>

</bean>

构建我们的 MethodCacheInterceptor

该拦截器实现org.aopalliance.intercept.MethodInterceptor接口。一旦运行起来(kicks-in)，它首先检查被拦截方法是否被配置为可缓存的。这将可选择性的配置想要缓存的 bean 方法。只要调用的方法配置为可缓存，拦截器将为该方法生成 cache key 并检查该方法返回的结果是否已缓存。如果已缓存，就返回缓存的结果，否则再次调用被拦截方法，并缓存结果供下次调用。

com.ph.serviceportal.infoboard.util.MethodCacheInterceptor

package com.ph.serviceportal.infoboard.util;

import java.io.Serializable;

import net.sf.ehcache.Cache;

import net.sf.ehcache.Element;

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.util.Assert;

public class MethodCacheInterceptor implements MethodInterceptor,
        InitializingBean {
    private static final Log logger = LogFactory
            .getLog(MethodCacheInterceptor.class);

    private Cache cache;

    public void setCache(Cache cache) {
        this.cache = cache;
    }

    /**
     *
     */
    public MethodCacheInterceptor() {
        super();
        // TODO 自动生成构造函数存根
    }

    /**
     * 主方法
     * 如果某方法可被缓存就缓存其结果
     * 方法结果必须是可序列化的(serializable)
     */
    public Object invoke(MethodInvocation invocation) throws Throwable {
        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();
        Object[] arguments = invocation.getArguments();
        Object result;

        logger.debug("在缓存中查找方法返回的对象!");
        String cacheKey = getCacheKey(targetName, methodName, arguments);
        Element element = cache.get(cacheKey);
        if (element == null) {
            logger.debug("正在拦截方法!");
            result = invocation.proceed();

            logger.debug("正在缓存对象!");
            element = new Element(cacheKey, (Serializable)result);
            cache.put(element);
        }
        return element.getValue();
    }

    /**
     *创建一个缓存对象的标识: targetName.methodName.argument0.argument1...
     */
    private String getCacheKey(String targetName, String methodName,
            Object[] arguments) {
        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();
    }

    /* （非 Javadoc）
     * @see org.springframework.beans.factory.InitializingBeanafterPropertiesSet()
     */
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(cache, "需要一个缓存. 使用setCache(Cache)分配一个.");

    }
}

com.ph.serviceportal.infoboard.util.MethodCacheAfterAdvice

package com.ph.serviceportal.infoboard.util;

import java.lang.reflect.Method;

import net.sf.ehcache.Cache;

import org.springframework.aop.AfterReturningAdvice;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.util.Assert;

public class MethodCacheAfterAdvice implements AfterReturningAdvice,
        InitializingBean {

    private Cache cache;

    public void setCache(Cache cache) {
        this.cache = cache;
    }

    /**
     *
     */
    public MethodCacheAfterAdvice() {
        super();
    }

    /*
     * （非 Javadoc）
     *
     * @see org.springframework.aop.AfterReturningAdviceafterReturning(java.lang.Object,
     *      java.lang.reflect.Method, java.lang.Object[], java.lang.Object)
     */
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        StringBuffer buffer = new StringBuffer();
        buffer.append(arg3.getClass().getName()).append(".").append(
                arg1.getName());
        if (arg2 != null && arg2.length != 0) {
            for (int i = 0; i < arg2.length; i++) {
                buffer.append(".").append(arg2[i]);
            }

        }
        cache.remove(buffer);
    }

    /*
     * （非 Javadoc）
     *
     * @see org.springframework.beans.factory.InitializingBeanafterPropertiesSet()
     */
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(cache, "需要一个缓存. 使用setCache(Cache)分配一个.");
    }
}

MethodCacheInterceptor 代码说明了：

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

使用 MethodCacheInterceptor

下面摘录了怎样配置 MethodCacheInterceptor and MethodCacheAfterAdvice：

<bean id="methodCacheInterceptor"

class="com.ph.serviceportal.infoboard.util.MethodCacheInterceptor">

</property>

</bean>

<bean id="methodCacheAfterAdvice"

class="com.ph.serviceportal.infoboard.util.MethodCacheAfterAdvice">

</property>

</bean>

<bean id="methodCachePointCut"

class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

</property>

<list>

</list>

</property>

</bean>

<bean id="methodCacheAdvicePointCut"

class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

</property>

<list>

<value>.*delete.*</value>

</list>

</property>

</bean>

结合上一篇文章，我们有如下配置： spring+JAX-RPC(Axis) 构建webservice

<bean name="infoboardService"

class="com.ph.serviceportal.infoboard.service.InfoBoardServiceImpl">

</bean>

<bean name="infoboardDAO"

class="com.ph.serviceportal.infoboard.dao.InfoboardDAOImpl">

</property>

</bean>

<bean id="infoboardServiceRpcProxy"

class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">

<value>

com.hp.serviceportal.infoboard.dao.IInfoboardDAO

</value>

</property>

<value>

http://qatest17.mro.cpqcorp.net/infoboard_ws_1100/infoboard.asmx?wsdl

</value>

</property>

<value>http://tempuri.org/InfoBoard_WS/Service1</value>

</property>

<value>Service1</value>

</property>

<value>Service1Soap</value>

</property>

<value>

org.tempuri.InfoBoard_WS.Service1.Service1Soap

</value>

</property>

</bean>

对infoboardservice进行增强:

<bean id="infoboardServiceCacheProxy"

class="org.springframework.aop.framework.ProxyFactoryBean">

<value>com.ph.serviceportal.infoboard.service.IInfoBoardService</value>

</property>

</property>

<list>

<value>methodCachePointCut</value>

<value>methodCacheAfterAdvice</value>

</list>

</property>

</bean>

<完>

分享到：

Neither any mapped-name/lookup/jndi-name ... | hibernate ehcache

2013-03-06 17:18
浏览 1114
评论(0)
分类:企业架构
查看更多

发表评论

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

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

ehcache

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

ehcache

评论

发表评论

相关推荐

最近访客更多访客>>