基于注解的方法缓存

在web项目中, 查询数据库非常耗时耗资源, 所以, 对于同一方法相同参数的请求, 应该保存到缓存中, 而不是每次都去查数据库, 方法的返回值可以保存到Mongodb或redis中

具体实现:

@MethodCache注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodCache {

/**
 * 指定缓存的过期时间, 默认60秒
 *
 * @return int
 */
int expireSeconds() default 60;

/**
 * 缓存的key, 如果不指定, 默认按照方法的签名作为key
 *
 * @return String
 */
String key() default "";

/**
 * 缓存防击穿的标志, 默认是开启防击穿功能
 *
 * @return boolean
 */
boolean limitQuery() default true;

/**
 * 防击穿的时限
 *
 * @return int
 */
int limitQuerySeconds() default 5;

/**
 * 是否保存空的结果
 *
 * @return boolean
 */
boolean saveEmptyResult() default true;

}
MethodCacheAspect切面

该切面的核心思想就是用方法的签名+实参对象的哈希值作为key, 先从缓存中取, 取不到再调用具体方法去查询, 查询结果后保存到缓存中, 其中可以设置一次只能有一个线程去查, 还可以设置重试次数, 还可以设置是否保存空结果

@Aspect
@Order(value = 2)
@Component
public class MethodCacheAspect {

@Resource
private JedisPool jedisPool;

@Resource
private DisLockUtil disLockUtil;

private static final Logger LOGGER = LoggerFactory.getLogger(MethodCacheAspect.class);

private static final String EMPTY_RESULT = "NULL";

/**
 * 切面具体的操作
 *
 * @param proceedingJoinPoint 切面
 * @param methodCache         注解
 * @return Object
 * @throws Throwable 抛出异常
 */
@Around("@annotation(methodCache)")
public Object execute(ProceedingJoinPoint proceedingJoinPoint, MethodCache methodCache) throws Throwable {
    MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
    Method method = methodSignature.getMethod();

    // 方法参数解析
    int size = proceedingJoinPoint.getArgs().length;
    // 解析请求参数
    List<Object> list = parseRequestParam(proceedingJoinPoint, size);
    // 根据方法获取相应的key
    String key = methodCache.key();
    if (StringUtils.isBlank(key)) {
        key = getSignature(method);
    }
    key += HashAlgorithms.mixHash(JSON.toJSONString(list));
    Object deserialize = tryGetFromCache(key);
    if (deserialize != null) {
        // 防止缓存击穿, 查询不到数据时也会设置空结果的标记, 避免直接把压力落到DB上
        if (EMPTY_RESULT.equals(deserialize)) {
            return null;
        }
        return deserialize;
    }
    Object proceed;
    String mutexKey = "mutex_" + key;
    if (methodCache.limitQuery()) {
        boolean lock = disLockUtil.lock(mutexKey, methodCache.limitQuerySeconds());
        // 如果第一次设置分布式锁失败, 最多允许重试三次
        int count = 1;
        while (!lock && count < 3) {
            lock = disLockUtil.lock(mutexKey, methodCache.limitQuerySeconds());
            count++;
            TimeUnit.SECONDS.sleep(1);
        }
        if (lock) {
            // 允许查询
            proceed = executeConcreteMethod(proceedingJoinPoint, mutexKey);
            Object cacheResult = proceed;
            // 缓存中不存在, 需要执行方法查询
            if (cacheResult == null) {
                cacheResult = EMPTY_RESULT;
            }
            try (Jedis jedis = jedisPool.getResource()) {
                jedis.setnx(key.getBytes(), KryoUtil.writeToByteArray(cacheResult));
                jedis.expire(key, methodCache.expireSeconds());
            }
        } else {
            LOGGER.warn("设置防击穿锁失败, key为:{}", mutexKey);
            throw new CustomException(ErrorCodeEnum.DUPLICATE_REQUEST.getMessage());
        }
    } else {
        // 允许查询
        proceed = executeConcreteMethod(proceedingJoinPoint, mutexKey);
    }
    return proceed;
}

/**
 * 执行具体的方法
 *
 * @param proceedingJoinPoint 切面
 * @return Object
 * @throws Throwable 异常
 */
private Object executeConcreteMethod(ProceedingJoinPoint proceedingJoinPoint, String mutexKey) throws Throwable {
    Object proceed;
    try {
        proceed = proceedingJoinPoint.proceed();
    } finally {
        disLockUtil.unlock(mutexKey, false);
    }
    return proceed;
}

/**
 * 尝试从缓存中获取
 *
 * @param key key
 * @return Object
 */
private Object tryGetFromCache(String key) {
    byte[] resultBytes;
    try (Jedis jedis = jedisPool.getResource()) {
        if (!jedis.exists(key)) {
            return null;
        }
        resultBytes = jedis.get(key.getBytes());
    }
    if (resultBytes != null) {
        LOGGER.info("key:{}获取到缓存", key);
        return KryoUtil.readFromByteArray(resultBytes);
    }
    return null;
}

/**
 * 解析请求参数
 *
 * @param proceedingJoinPoint 切面
 * @param size 参数个数
 * @return List<Object>
 */
private List<Object> parseRequestParam(ProceedingJoinPoint proceedingJoinPoint, int size) {
    Object[] args = proceedingJoinPoint.getArgs();
    List<Object> argList = new ArrayList<>();
    for (int i = 0; i < size; i++) {
        if (args[i] instanceof HttpServletRequest) {
            HttpServletRequest request = (HttpServletRequest) args[i];
            argList.add(request.getParameterMap());
        } else if (args[i] instanceof HttpServletResponse || args[i] instanceof HttpSession
                || args[i] instanceof HttpCookie) {
            continue;
        } else {
            argList.add(args[i]);
        }
    }
    return argList;
}

/**
 * 生成方法签名
 *
 * @param method 方法
 * @return String
 */
private String getSignature(Method method) {
    StringBuilder sb = new StringBuilder();
    String methodName = method.getName();
    if (StringUtils.isNotBlank(methodName)) {
        sb.append(method).append("#");
    }
    return sb.toString();
}

}