手把手教你做一个缓存工具

日常开发中，某些数据接口即使优化到极致，都难免还会存在计算量巨大导致响应过慢，多数情况单独做一个统计表用于存放这些处理后的数据用于读取，或者接入redis/memcache存数据，就是说单次响应本身是可以接受较慢一些的，实时性并非特别高，则可以考虑引入缓存机制，提升使用体验。说到用缓存，那就会有人提出用redis，但是项目组认为项目紧急，不希望浪费时间到新的工具研究上，或虽然熟悉，但维护工作有成本，为了有限的效果付出太多不划算。那么怎么办，没得搞了，只能手把手给项目做一个缓存工具了！吃掉JVM！也和spring cache很类似的。

这样的缓存机制，无非就是key-value模型的体现，所以首先想到了map。

Map<String, Object> cache = new HashMap<>();

一个缓存工具就完成了，快吧。怎么用的话，就类似这样嘛：

@GetMapping("/{id}")
public Object get(@PathVariable("id") String id) {
  if (cache.containKey(id)) {
    return cache.get(id);
  }
  //  调取服务获取对象
  Object obj = service.get(id);
  //  塞进缓存中
  cache.put(id, obj);
  return obj;
}

挺好用的，既方便效果又达成。

但是一想到是JVM的内存，那么对象是存放在堆中的，一旦发生GC，数据被清掉了呢，会不会在下面这个操作的时候，我containKey判断它的确存在，但是到了return的时候，应该返回的对象没有了。

if (cache.containKey(id)) {
  return cache.get(id);
}

这的确是个问题，需要防止它发生。有办法，换个思路写上面的代码：

Object obj = cache.get(id);
if (obj != null) {
  return obj;
}

这样写总可以了吧，对象真的存在的时候我才给直接返回，不然还是老老实实执行查询对象的方法。

好是挺好，但是总不至于每次一个类，我就得它new一个Map吧，那得多费Map，而且Map可以存在很多的对象在里面，只要它的Key不重复。

考虑下Spring的组件处理，其实也是抽Map成类，当然可以将Map放到一个类中做静态属性字段。Map的重复利用算是解决了。但是缓存的数据不是一直都不变的，那还需要给它来一个定时，刷走缓存数据。

@Component
public Cache<String, Object> extends HashMap<String, Object> {
  
  @Scheduled(cron="0 0/5 * * * ?")
  public void flushCache() {
    clear();
  }
    
}

其实这样做还是不够灵活，应该更能定制化地刷走缓存，有些数据是5分钟才变化，但有些数据一天都不变呢。这样的话，可以考虑用Java的定时器，对上面进行优化，定时删除指定的数据。

缓存的地方有了，定时刷新有了，但是仍然不好用，因为每个方法我都需要写代码去判断是否存在缓存。为了解决这个问题，很自然地想到了加注解，AOP做切面，交给切面去处理，很快，就做出来了。

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CachePut {

  String key() default "";

}

再把切面实现下：

@Aspect
@Component
public class CachePutAspect {

  @Autowired
  private Cache cache;

  @Pointcut("@annotation(com.lin.cache.Cache)")
  public void cachePointCut() {
  }

  @SuppressWarnings("rawtypes")
  @Around("cachePointCut()")
  public Object pointCut(ProceedingJoinPoint pjp) throws Exception {
    Object result = null;
    String methodName = pjp.getSignature().getName();
    Class<?> classTarget = pjp.getTarget().getClass();
    Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
    Method method = classTarget.getMethod(methodName, par);
    CachePut cachePut = method.getAnnotation(CachePut.class);
    if (cachePut != null) {
      result = cache.get(cacheImport.key());
      //  避免获取结果时遇上clear操作
      if (result != null) {
        return result;
      }
      try {
        result = pjp.proceed();
        //  将结果缓存
        cacheMap.put(key, result);
      } catch (Throwable throwable) {
        throw new Exception("方法错误");
      }
    }
    return result;
  }

}

使用的时候就是这样的了。

@CachePut(key = "getId")
@GetMapping("/{id}")
public Object get(@PathVariable("id") String id) {
  //  调取服务获取对象
  Object obj = service.get(id);
  return obj;
}

好像还是不对劲的，因为key都是固定是"getId"，岂不是每个不同对象都被覆盖掉了，但肯定不行，那怎么办。想起来之前用redis做缓存的时候，用的spring的缓存@CachePut(key = "info + #id")，从方法的入参那里拿到唯一的标识，将缓存结果区分开来，这里网上的资料比较少，啃源码一下子没看明白，怎么想都觉得这个操作很简单。直到偶尔翻翻，找到有人提供了一个可行的例子，才得以让这个缓存工具得到升华。

@Aspect
@Component
public class CachePutAspect {

  @Autowired
  private Cache cache;

  @Pointcut("@annotation(com.lin.cache.Cache)")
  public void cachePointCut() {
  }

  @SuppressWarnings("rawtypes")
  @Around("cachePointCut()")
  public Object pointCut(ProceedingJoinPoint pjp) throws Exception {
    Object result = null;
    String methodName = pjp.getSignature().getName();
    Class<?> classTarget = pjp.getTarget().getClass();
    Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
    Method method = classTarget.getMethod(methodName, par);
    CachePut cachePut = method.getAnnotation(CachePut.class);
    if (cachePut != null) {
      String key = generateKeyBySpEL(cacheImport.key(), pjp);
      result = cacheMap.get(key);
      //  避免获取结果时遇上clear操作
      if (result != null) {
        return result;
      }
      try {
        result = pjp.proceed();
        //  将结果缓存
        cacheMap.put(key, result);
      } catch (Throwable throwable) {
        throw new Exception("方法错误");
      }
    }
    return result;
  }

  //  使用SpringEL，将入参数据和表达式绑定起来，得到Key  
  public String generateKeyBySpEL(String key, ProceedingJoinPoint pjp) {
    Expression expression = parserSpel.parseExpression(key);
    EvaluationContext context = new StandardEvaluationContext();
    MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
    Object[] args = pjp.getArgs();
    String[] paramNames = parameterNameDiscoverer
        .getParameterNames(methodSignature.getMethod());
    for(int i = 0 ; i < args.length ; i++) {
      context.setVariable(paramNames[i], args[i]);
    }
    return expression.getValue(context).toString();
  }
    
}

现在就可以这样用灵活的注解了：

@CachePut(key = "'info-' + #id)

差不多了完成这个缓存工具了，当然除了将结果放进缓存的操作用注解处理，把缓存移除的操作也可以用注解完成。这里就不实现了。

enn。。好像和Spring Cache的比较像，将就吧。