encache整合spring应用实例

本文章摘编、转载需要注明来源 http://write.blog.csdn.net/postedit/8599512

缓存热点数据是提高访问效率的重要手段之一,下面我用encache演示下如何做service层的数据缓存

先写个方法拦截器,当然要先继承MethodInterceptor,encache的标识key我是将参数序列成json字符

 

可能强制部分会影响性能,建议判断null后再一次判断cache.get(key)是否为null,同步的第一人的操作已经执行完毕,那element里面就不为null,这样其他的并发用户就不需要

继续再执行put值的操作,这样做应该能比较好地降低synchronized带来的负面影响

/**
* 缓存方法拦截器核心代码
*
* @author shadow
* @email 124010356@qq.com
* @create 2012.04.28
*/
public class EhCacheMethodInterceptor implements MethodInterceptor,
InitializingBean {

// private static final Logger log = Logger.getLogger(MethodCacheInterceptor.class);

private Cache cache;

public EhCacheMethodInterceptor() {
super();
}

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

public void afterPropertiesSet() throws Exception {
// /log.info(cache A cache is required. Use setCache(Cache) to provide one.");
}

public Object invoke(MethodInvocation invocation) throws Throwable {
String targetName = invocation.getThis().getClass().getName();
String methodName = invocation.getMethod().getName();
Object[] arguments = invocation.getArguments();
String cacheKey = getCacheKey(targetName, methodName, arguments);
Element element = cache.get(cacheKey);

// 缓存节点不存在的情况
if (null == element) {
synchronized (this) {
// 这里判断是为了降低强制同步的负面影响,只需第一个操作该添加过程,后来者则跳过
if (null == cache.get(cacheKey))
element = putValueToCache(invocation, element, cacheKey);
}
}
// 返回缓存值
return element.getValue();

}

// 新增节点放到缓存区
private Element putValueToCache(MethodInvocation invocation,
Element element, String cacheKey) throws Throwable {
Object result = invocation.proceed();
element = new Element(cacheKey, (Serializable) result);
cache.put(element);
return element;
}

/**
*
* 返回具体的方法(全路径+方法名+参数值)
*
* @param targetName
*            全路径
* @param methodName
*            方法名称
* @param arguments
*            参数(转换成JSON格式方便比较)
* @return String
*/
private String getCacheKey(String targetName, String methodName,
Object[] arguments) {
StringBuffer buffer = new StringBuffer("");
buffer.append(targetName).append(".").append(methodName);
for (Object argument : arguments) {
buffer.append(".")
.append(BaseSupport.ContextUtil.getJSON(argument));
}
return buffer.toString();
}

}

再做个同步数据的限制类,当我们执行remove等那些方法的时候会清空encache里面的相关缓存的方法数据,下次再访问的时候会重新在数据库里读取更新后的数据,到这里基本就可以了

package com.shadow.extras.cache;

import java.util.List;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;

/**
* 缓存数据变动后让数据保持同步状态
*
* @author shadow
* @email 124010356@qq.com
* @create 2012.04.28
*/
public class EhCacheMethodAfterAdvice {

protected final Logger logger = Logger.getLogger(getClass());

private CacheManager cacheManager;
private Cache cacheName;

/**
* 原始数据发生变更时保持强一致性(刪除緩存管理器里指定key的value)
*
* @param joinPoint
*/
public void afterReturning(JoinPoint joinPoint) {
// String methodName = joinPoint.getSignature().getName();// 得到执行的方法

if (cacheManager != null && cacheName != null) {
// 获取缓存堆
Class<?> clazz = joinPoint.getTarget().getClass();
List<?> list = cacheName.getKeys();
for (int i = 0, len = list.size(); i < len; i++) {
String key = String.valueOf(list.get(i));
if (key.startsWith(clazz.getName()))
cacheName.remove(key);
}
} else {
if (cacheManager == null)
logger.error("缓存管理器不存在!");
if (cacheName == null)
logger.error("缓存堆不存在!");
}
}

public CacheManager getCacheManager() {
return cacheManager;
}

public void setCacheManager(CacheManager cacheManager) {
this.cacheManager = cacheManager;
}

public Cache getCacheName() {
return cacheName;
}

public void setCacheName(Cache cacheName) {
this.cacheName = cacheName;
}

}

然后是在xml里配置需要拦截的方法

<?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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:ehcache="http://www.springframework.org/schema/ehcache"
xsi:schemaLocation=" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/ehcache http://www.springframework.org/schema/cache/springmodules-ehcache.xsd">
<!-- 配置缓存管理器 -->
<bean id="defaultCacheManager"
class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
<property name="configLocation">
<value>classpath:ehcache.xml</value>
</property>
</bean>

<!-- 配置一个简单的缓存工厂bean对象 -->
<bean id="defaultCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheManager">
<ref local="defaultCacheManager" />
</property>
<!-- 使用缓存 关联ehcache.xml中的缓存配置 -->
<property name="cacheName" value="defaultCache" />
</bean>

<!-- 配置一个简单的缓存工厂bean对象 -->
<bean id="commonCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheManager">
<ref local="defaultCacheManager" />
</property>
<!-- 使用缓存 关联ehcache.xml中的缓存配置 -->
<property name="cacheName" value="commonCache" />
</bean>

<!-- 配置一个缓存拦截器对象，处理具体的缓存业务 -->
<bean id="ehCacheMethodInterceptor" class="com.shadow.extras.cache.EhCacheMethodInterceptor">
<property name="cache" ref="defaultCache" />
</bean>

<!-- 参与缓存的切入点对象 (切入点对象，确定何时何地调用拦截器) -->
<bean id="methodCachePointCut"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 配置缓存切面 -->
<property name="advice" ref="ehCacheMethodInterceptor" />
<!--
配置哪些方法参与缓存策略 .表示符合任何单一字元 ### +表示符合前一个字元一次或多次 ### *表示符合前一个字元零次或多次 ###
\Escape任何Regular expression使用到的符号
-->
<!-- .*表示前面的前缀(包括包名) 表示print方法-->
<property name="patterns">
<list>
<value>
com.xshadow.mvc.service\..*Service.*\.find.*
</value>
</list>
</property>
</bean>

<!-- 配置一个缓存拦截器对象，处理具体的同步缓存业务 -->
<bean id="ehCacheMethodAfterAdvice" class="com.shadow.extras.cache.EhCacheMethodAfterAdvice">
<property name="cacheManager" ref="defaultCacheManager" />
<property name="cacheName" ref="defaultCache" />
</bean>
<aop:config>
<aop:aspect id="methodCachePointCutAdviceAspect" ref="ehCacheMethodAfterAdvice">
<aop:after method="afterReturning"
pointcut="execution(* com.shadow.mvc.service.*Service.modify*(..))" />
<aop:after method="afterReturning"
pointcut="execution(* com.shadow.mvc.service.*Service.save*(..))" />
<aop:after method="afterReturning"
pointcut="execution(* com.shadow.mvc.service.*Service.remove*(..))" />
</aop:aspect>
</aop:config>

</beans>


以后我们配置需要缓存的地方就直接在文件里配置就可以了,至于分布式的缓存应用有空再写