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

日常开发中,某些数据接口即使优化到极致,都难免还会存在计算量巨大导致响应过慢,多数情况单独做一个统计表用于存放这些处理后的数据用于读取,或者接入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的比较像,将就吧。

posted @ 2020-07-04 13:59  林嘉瑜  阅读(207)  评论(0编辑  收藏