设计到的内容：

  • 本地缓存：caffeine 使用
  • redis 缓存：和本地缓存结合
  • double check
  • 自定义缓存注解
  • 表达式语言 Spring Expression Language
  • LocalVariableTableParameterNameDiscoverer 获取方法的参数名

1. 目录结构

image.png
单独设置一个分包，用来统一管理缓存，并且缓存类型（本地缓存、redis 缓存）放入 strategy 包下。

2. 本地缓存基础类

  1. import com.github.benmanes.caffeine.cache.*;
  2. import lombok.extern.slf4j.Slf4j;
  4. import java.util.List;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * @description: 本地缓存基础类
  9.  */
  10. @Slf4j
  11. public abstract class BaseCache {
  13.     /**
  14.      * 缓存对象
  15.      */
  16.     private LoadingCache cache;
  18.     /**
  19.      * 缓存最大容量，默认为 10
  20.      */
  21.     protected Integer maximumSize = 1024;
  23.     /**
  24.      * 缓存失效时长
  25.      */
  26.     protected Long duration = 300L;
  28.     /**
  29.      * 缓存失效单位，默认为 5s
  30.      */
  31.     protected TimeUnit timeUnit = TimeUnit.SECONDS;
  33.     /**
  34.      * @description: 获取cache
  35.      */
  36.     private LoadingCache<String, Object> getCache() {
  37.         if (cache == null) {
  38.             synchronized (BaseCache.class) {
  39.                 if (cache == null) {
  40.                     LoadingCache<String, Object> tempCache = Caffeine.newBuilder()
  41.                             .maximumSize(maximumSize)
  42.                             .expireAfterWrite(duration, timeUnit)
  43.                             .removalListener((RemovalListener<String, Object>) (key, value, cause) -> {
  44.                                 log.warn("剔除监听 > key:{}, value:{}, cause:{}", key, value, cause.toString());
  45.                             })
  46.                             .build(key -> getLoadData(key));
  47.                     cache = tempCache;
  48.                 }
  49.             }
  50.         }
  51.         return cache;
  52.     }
  54.     /**
  55.      * @description:返回加载到内存中的数据，一般从数据库中加载
  56.      */
  57.     public abstract Object getLoadData(String key);
  59.     /**
  60.      * @description:如果getLoadData返回值为null，返回的默认值
  61.      */
  62.     public abstract Object getLoadDataIfNull(String key);
  64.     /**
  65.      * @description:批量清除缓存
  66.      */
  67.     public void batchInvalidate(List<String> keys) {
  68.         if (keys != null) {
  69.             getCache().invalidateAll(keys);
  70.         } else {
  71.             getCache().invalidateAll();
  72.         }
  73.     }
  75.     /**
  76.      * @description:清除缓存
  77.      */
  78.     public void invalidateOne(String key) {
  79.         getCache().invalidate(key);
  80.     }
  82.     /**
  83.      * @description:加入缓存
  84.      */
  85.     public void set(String key, Object value) {
  86.         getCache().put(key, value);
  87.     }
  89.     /**
  90.      * @description:获取缓存
  91.      */
  92.     public Object get(String key) {
  93.         return getCache().get(key);
  94.     }
  96.     public void del(String key, Long version, String eventType) {
  97.        invalidateOne(key);
  98.     }
  100. }

BaseCache 为缓存基础类，是一个抽象类。

3. 本地缓存类

  1. @Slf4j
  2. @Service
  3. public class CacheDefault extends BaseCache {
  5.     @Autowired
  6.     private RedisServiceImpl<String, Object> redisService;
  8.     /**
  9.      * @description:从redis中读取并加载到本地缓存
  10.      */
  11.     @Override
  12.     public Object getLoadData(String key) {
  13.         return redisService.get(key);
  14.     }
  16.     @Override
  17.     public MokaPackageModel getLoadDataIfNull(String key) {
  18.         return null;
  19.     }
  21.     /**
  22.      * @description:设置操作
  23.      */
  24.     @Override
  25.     public void set(String key, Object value) {
  26.         super.set(key, value);
  27.         redisService.set(key, value, duration, timeUnit);
  28.     }
  30.     /**
  31.      * @description:获取操作
  32.      */
  33.     @Override
  34.     public Object get(String key) {
  35.         return super.get(key);
  36.     }
  38.     /**
  39.      * @description:删除操作
  40.      */
  41.     @Override
  42.     public void del(String key, Long version, String eventType) {
  43.         try {
  44.             // 先从redis中获取，如果为空，可能是被其他机器删除了，也有可能本来就没有。
  45.             Object data = getLoadData(key);
  46.             if (data == null) {
  47.                 // 如果redis中没有，再从本地缓存获取，如果都没有，则返回
  48.                 data = get(key);
  49.                 if (data == null) {
  50.                     return;
  51.                 }
  52.             }
  53.             JSONObject localCacheJson = (JSONObject)JSONObject.toJSON(data);
  54.             String oldVersion = localCacheJson.getString("version");
  55.             if (StringUtils.isBlank(oldVersion)) {
  56.                 return;
  57.             }
  58.             log.info("CacheDefault del. oldVersion={}, newVersion={}", version, oldVersion);
  59.             if (BinlogEventTypeEnum.DELETE.getCode().equals(eventType)) {
  60.                 if (version >= Long.parseLong(oldVersion)) {
  61.                     super.del(key, version, eventType);
  62.                     redisService.delete(key);
  63.                 }
  64.             }
  65.             if (BinlogEventTypeEnum.UPDATE.getCode().equals(eventType)) {
  66.                 if (version > Long.parseLong(oldVersion)) {
  67.                     super.del(key, version, eventType);
  68.                     redisService.delete(key);
  69.                 }
  70.             }
  71.         } catch (Exception e) {
  72.             log.error("CacheDefault.del error.", e);
  73.         }
  74.     }
  76. }

�

3. 自定义注解

  1. @Target({ElementType.TYPE, ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MokaCache {
  5.     /**
  6.      * 缓存前缀
  7.      */
  8.     String prefix();
  9.     /**
  10.      * 分割符
  11.      */
  12.     String separator() default ":";
  13.     /**
  14.      * 缓存key定义
  15.      */
  16.     String key();
  17.     /**
  18.      * 是否开启缓存加载
  19.      */
  20.     boolean turn() default true;
  21.     /**
  22.      * 失效时间
  23.      */
  24.     long expire() default 1800L;
  25.     /**
  26.      * 失效时间是否随机
  27.      */
  28.     boolean random() default false;
  29.     /**
  30.      * 失效时间范围：最小值
  31.      */
  32.     long minExpire() default 1800L;
  34.     /**
  35.      * 失效时间范围：最大值
  36.      */
  37.     long maxExpire() default 3600L;
  38.     /**
  39.      * 失效时间单位
  40.      */
  41.     TimeUnit timeUnit() default TimeUnit.SECONDS;
  42. }

4. AOP 拦截器

  1. @Aspect
  2. @Component
  3. @Slf4j
  4. public class MokaCacheAop {
  6.     LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
  8.     @Autowired
  9.     private KVConfig kvConfig;
  10.     @Autowired
  11.     private CacheDefault cacheDefault;
  13.     @Around("@annotation(com.hwl.moka.cache.annotation.MokaCache)")
  14.     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
  15.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
  16.         Method method = signature.getMethod();
  17.         // 获得参数值
  18.         Object[] args = joinPoint.getArgs();
  19.         MokaCache mokaCache = method.getAnnotation(MokaCache.class);
  20.         // 总开关关闭或者当前开关关闭，直接返回
  21.         if (!kvConfig.mokaCacheSwitch || !mokaCache.turn()) {
  22.             return joinPoint.proceed(args);
  23.         }
  24.         // 获得参数名
  25.         String[] paramNames = discoverer.getParameterNames(method);
  26.         SpelParser<String> parser = new SpelParser<>();
  27.         EvaluationContext context = parser.setAndGetContextValue(paramNames, args);
  28.         String prefix = mokaCache.prefix();
  29.         if (StringUtils.isBlank(prefix)) {
  30.             log.error("注解MokaCache参数prefix为空. method={}", method);
  31.             return joinPoint.proceed(args);
  32.         }
  33.         //解析SpEL表达式
  34.         String cacheKey = mokaCache.key();
  35.         if (StringUtils.isBlank(cacheKey)) {
  36.             log.error("注解MokaCache参数key为空. method={}", method);
  37.             return joinPoint.proceed(args);
  38.         }
  39.         List<String> cacheKeyList = splitSuper(cacheKey, "#");
  40.         StringBuilder keyBuilder = new StringBuilder(prefix).append(mokaCache.separator());
  41.         for (String key : cacheKeyList) {
  42.             keyBuilder.append(String.valueOf(parser.parse(key, context))).append(mokaCache.separator());
  43.         }
  44.         String key = keyBuilder.substring(0, keyBuilder.length() - 1);
  45.         // 从缓存中获取
  46.         Object cache = cacheDefault.get(key);
  47.         if (cache != null) {
  48.             log.info("cache hit. prefix={}, key={}", prefix, key);
  49.             return cache;
  50.         }
  51.         log.info("cache miss. prefix={}, key={}", prefix, key);
  52.         // 执行业务方法
  53.         Object proceed = joinPoint.proceed(args);
  54.         // 将数据存入缓存中
  55.         cacheDefault.set(key, proceed, mokaCache.expire(), mokaCache.timeUnit());
  56.         return proceed;
  57.     }
  59.     public static List<String> splitSuper(String str, String split) {
  60.         String[] splitArr = str.split(split);
  61.         List<String> result = new ArrayList<>();
  62.         for (String s : splitArr) {
  63.             if (StringUtils.isBlank(s)) {
  64.                 continue;
  65.             }
  66.             result.add(split + s);
  67.         }
  68.         return result;
  69.     }
  70. }

5. 解析器

  1. public class SpelParser<T> {
  3.     /**
  4.      * 表达式解析器
  5.      */
  6.     ExpressionParser parser = new SpelExpressionParser();
  8.     /**
  9.      * 解析SpEL表达式
  10.      *
  11.      * @param spel
  12.      * @param context
  13.      * @return T 解析出来的值
  14.      */
  15.     public T parse(String spel, EvaluationContext context) {
  16.         return (T) parser.parseExpression(spel).getValue(context);
  17.     }
  19.     /**
  20.      * 将参数名和参数值存储进EvaluationContext对象中
  21.      *
  22.      * @param object 参数值
  23.      * @param params 参数名
  24.      * @return EvaluationContext对象
  25.      */
  26.     public EvaluationContext setAndGetContextValue(String[] params, Object[] object) {
  27.         EvaluationContext context = new StandardEvaluationContext();
  28.         for (int i = 0; i < params.length; i++) {
  29.             context.setVariable(params[i], object[i]);
  30.         }
  31.         return context;
  32.     }
  33. }

6. 使用

  1. @MokaCache(prefix = "cache:test", key = "#id#name#age")
  2. public String getByParam(String id, String name, int age) {
  3.     return id + name + age;
  4. }

7. 说明

  • LocalVariableTableParameterNameDiscoverer discoverer 是获取方法的参数名列表，用于之后根据 key = "#id#name#age" 解析出对应参数的值，来组装缓存的 key

  • AOP 类中还用到了 Spring Expression language（SpEL），主要用于根据注解中的 "#id#name#age" 来解析出对应的值。因为入参可能有多个，因此需要先分隔再依次解析出参数值，最后拼装成 key 去使用。

  • 最后如果没有查询到值的话，调用 Object proceed = joinPoint.proceed(args); 方法获取执行结果并进行缓存。

�

�