Java开发框架spring实现自定义缓存标签

Java开发框架spring实现自定义缓存标签

自从spring3.1之后，spring引入了抽象缓存，可以通过在方法上添加@Cacheable等标签对方法返回的数据进行缓存。但是它到底是怎么实现的呢，我们通过一个例子来看一下。首先我们定义一个@MyCacheable

package caching.springaop;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import java.lang.annotation.ElementType;

/**

* 使用@MyCacheable注解方法

*/

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface MyCacheable{

}

然后定义处理MyCacheable的切面

package caching.springaop;

import java.util.HashMap;

import java.util.Map;

import org.apache.log4j.Logger;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

/**

* 处理MyCacheable方法的切面

*/

@Aspect

public class CacheAspect {

private Logger logger = Logger.getLogger(CacheAspect.class);

private Map http://cache;

public CacheAspect() {

cache = new HashMap();

}

/**

* 所有标注了@Cacheable标签的方法切入点

*/

@Pointcut("execution(@MyCacheable * *.*(..))")

@SuppressWarnings("unused")

private void cache() {

}

@Around("cache()")

public Object aroundCachedMethods(ProceedingJoinPoint thisJoinPoint)

throws Throwable {

logger.debug("Execution of Cacheable method catched");

//产生缓存数据的key值，像是这个样子caching.aspectj.Calculator.sum(Integer=1;Integer=2;)

StringBuilder keyBuff = new StringBuilder();

//增加类的名字

keyBuff.append(thisJoinPoint.getTarget().getClass().getName());

//加上方法的名字

keyBuff.append(".").append(thisJoinPoint.getSignature().getName());

keyBuff.append("(");

//循环出cacheable方法的参数

for (final Object arg : thisJoinPoint.getArgs()) {

//增加参数的类型和值

keyBuff.append(arg.getClass().getSimpleName() + "=" + arg + ";");

}

keyBuff.append(")");

String key = keyBuff.toString();

logger.debug("Key = " + key);

Object result = cache.get(key);

if (result == null) {

logger.debug("Result not yet cached. Must be calculated...");

result = thisJoinPoint.proceed();

logger.info("Storing calculated value '" + result + "' to cache");

cache.put(key, result);

} else {

logger.debug("Result '" + result + "' was found in cache");

return result;

}

}

上述代码展示了如何处理MyCacheable自定义的标签，以及默认情况下产生key值的规则。最后生成的key值大概是这个样子：caching.aspectj.Calculator.sum(Integer=1;Integer=2;)

下边这段代码在方法上添加了MyCacheable标签

package caching.springaop;

import org.apache.log4j.Logger;

public class Calculator {

private Logger logger = Logger.getLogger(Calculator.class);

@MyCacheable

public int sum(int a, int b) {

logger.info("Calculating " + a + " + " + b);

try {

//假设这是代价非常高的计算

Thread.sleep(3000);

} catch (InterruptedException e) {

logger.error("Something went wrong...", e);

}

return a + b;

}

}

在方法上加了MyCacheable标签，当key值相同的情况下会直接在缓存中获取数据，如果没有相同的key值，则会重新计算，因为这里只是一个加和操作，耗时非常的短暂。我们在这里让其睡眠3秒钟。

我们在spring-config.xml配置如下：

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xmlns:aop="http://springframework.org/schema/aop"

xsi:schemaLocation="http://springframework.org/schema/aop http://springframework.org/schema/aop/spring-aop-2.5.xsd

http://springframework.org/schema/beans http://springframework.org/schema/beans/spring-beans-2.5.xsd">

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xmlns:aop="http://springframework.org/schema/aop"

xsi:schemaLocation="http://springframework.org/schema/aop http://springframework.org/schema/aop/spring-aop-2.5.xsd

http://springframework.org/schema/beans http://springframework.org/schema/beans/spring-beans-2.5.xsd">

测试类：

package caching.springaop;

import org.apache.log4j.Logger;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

* 使用SpringAOP缓存的简单例子

* @author txxs

*/

public class App {

private static Logger logger = Logger.getLogger(App.class);

public static void main(String[] args) {

logger.debug("Starting...");

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");

Calculator calc = (Calculator) ctx.getBean("calc");

//计算出来的结果将会被存储在cache

loggertmZaxPh.info("1 + 2 = " + calc.sum(1, 2));

//从缓存中获取结果

logger.info("1 + 2 = " + calc.sum(1, 2));

logger.debug("Finished!");

}

}

我们看一下运行的结果：

从结果来看第一次直接计算结果，第二次从缓存中获取。

以上就是spring实现自定义缓存标签的全部内容，希望对大家的学习有所帮助

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。