前言
在系统架构层面,缓存是一个经常用到的技术,比如数据库缓存、接口缓存等等。自然在同一层级的应用服务里面也可以用到缓存技术,比如方法A调用方法B,而B是一个运算时间比较久或者是一个需要调用第三方接口获取到数据,那B方法的频繁调用肯定会影响请求的相应速度。对于这类问题也确实有一些解决方案,比如Spring提供的@Cacheable注解。但是看了下这个注解,没发现超时自动清空的属性,查了下别人貌似是用的定时任务实现的,所以就手动实现一个简单版的缓存注解把。
@Cacheable注解定义
因为就想实现各简单版的缓存功能,所以@cacheable注解的定义很简单,无非就是key的生成规则以及超时时间
import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
String key(); //缓存的key值
int[] param() default {}; //影响key的参数
long timeount() default 1L; //超时时间
TimeUnit timeUnit() default TimeUnit.SECONDS; //超时时间单位
}
AOP拦截器
aop提供了一个拦截注解的功能,因此实现起来会比较方便。示例代码使用了ConcurrentHashMap实现本地缓存,不过在实际开发中还是建议使用redis之类的第三方缓存工具。当然,本示例代码有一个很大的问题,那就是无法防止缓存击穿等情况。当然,只是应用在一些简单的方法逻辑上是完全没有问题的。
@Aspect
@Component
public class CacheAspect {
//缓存map,因为可能多线程调用,所以用ConcurrentHashMap。当然,推荐使用redis等第三方工具来完成缓存功能
private final Map<String,CacheObject> CACHE = new ConcurrentHashMap<>();
@Around(value = "@annotation(cacheable)")
public Object process(ProceedingJoinPoint pjp, Cacheable cacheable) throws Throwable {
//检查一下注解的参数是否有效
if (isCacheParamOutOfIndex(cacheable.param(),cacheable.param())){
return pjp.proceed();
}
//根据注解的定义参数和请求方法的参数获得缓存的key值
String key = getKey(cacheable,cacheable.param(),cacheable.param());
Object obj = get(key);
if (obj != null) {
//如果缓存里有值,则直接返回
return obj;
}
obj = pjp.proceed();
//记得将结果存入缓存中
set(key,obj,cacheable.timeount(),cacheable.timeUnit());
return obj;
}
private boolean isCacheParamOutOfIndex(int[] lable, int[] params) {
for (int index : lable) {
if (index >= params.length) {
return true;
}
}
return false;
}
private String getKey(Cacheable cacheable, int[] lable, int[] params) {
StringBuilder builder = new StringBuilder("cache_"+cacheable.key());
for (int index : lable){
//不要忘记把参数也加入key
builder.append("_");
builder.append(params[index]);
}
return builder.toString();
}
private void set(String s, Object obj, long timeout, TimeUnit timeUnit) {
//推荐使用redis等缓存工具实现
CACHE.put(s,new CacheObject(obj,timeout,timeUnit));
}
private Object get(String s) {
//推荐使用redis等缓存工具实现
CacheObject cacheObject = CACHE.get(s);
if (cacheObject == null || cacheObject.isTimeOut())
return null;
return cacheObject.getObj();
}
/**
* 内部辅助类
*/
private class CacheObject{
private Object obj;
private long cacheTimeMillis;
private long timeOutTime;
private TimeUnit timeUnit;
CacheObject(Object obj, long timeOutTime, TimeUnit timeUnit) {
this.obj = obj;
this.cacheTimeMillis = System.currentTimeMillis();
this.timeOutTime = timeOutTime;
this.timeUnit = timeUnit;
}
Object getObj() {
return obj;
}
boolean isTimeOut(){
return System.currentTimeMillis() > cacheTimeMillis + timeUnit.toMillis(timeOutTime);
}
}
}
跑一波
测试类
@Component
public class TestClass {
@Cacheable(key = "key1",param = {0})
public String test1(String param1) throws InterruptedException {
System.out.println("重新获得值。。。。test1");
Thread.sleep(100);
return String.valueOf(new Random().nextInt());
}
@Cacheable(key = "key1",param = {0,1})
public String test2(String param1,String param2) throws InterruptedException {
System.out.println("重新获得值。。。。test2");
Thread.sleep(100);
return String.valueOf(new Random().nextInt());
}
@Cacheable(key = "key2",param = {0,1})
public String test3(String param1,String param2) throws InterruptedException {
System.out.println("重新获得值。。。。test3");
Thread.sleep(100);
return String.valueOf(new Random().nextInt());
}
}
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestClassTest {
@Autowired
private TestClass testClass;
private long t1,t2;
@Test
public void test() throws InterruptedException {
t1 = System.currentTimeMillis();
System.out.println("获得结果为:"+testClass.test1("111"));
t2 = System.currentTimeMillis();
System.out.println("执行时间为:"+(t2 - t1));
t1 = System.currentTimeMillis();
System.out.println("获得结果为:"+testClass.test1("111"));
t2 = System.currentTimeMillis();
System.out.println("执行时间为:"+(t2 - t1));
Thread.sleep(1000); //休眠一秒,看缓存是否失效
t1 = System.currentTimeMillis();
System.out.println("获得结果为:"+testClass.test1("111"));
t2 = System.currentTimeMillis();
System.out.println("执行时间为:"+(t2 - t1));
//测试两个key相同,参数不同的方法
t1 = System.currentTimeMillis();
System.out.println("获得结果为:"+testClass.test2("111","222"));
t2 = System.currentTimeMillis();
System.out.println("执行时间为:"+(t2 - t1));
//测试两个key不同同,参数相同同的方法
t1 = System.currentTimeMillis();
System.out.println("获得结果为:"+testClass.test3("111","222"));
t2 = System.currentTimeMillis();
System.out.println("执行时间为:"+(t2 - t1));
}
}
结果
很明显,测试结果和预期结果完全符合