数据库
首页 > 数据库> > AOP 在业务代码织入 Redis 缓存

AOP 在业务代码织入 Redis 缓存

作者:互联网

 

  场景:页面包含多个大 sql。
  目的:尽量保证接口响应速度,数据库压力可暂不考虑(并发不大,耗时 sql 多)。
  思路:

  1、如果 redis 中不存在缓存,查询数据库并添加缓存,根据数据变化频率设置缓存过期时间;

  2、如果 redis 中存在缓存,提交更新缓存的异步任务(可选,针对数据变化频率高,但业务上不是特别敏感的情况),返回缓存;

  3、对于数据变化较频繁的接口,使用定时任务定时更新 redis 中的缓存(数据变化频率高,且业务敏感)。

  对于查询数据库并更新缓存的任务,需要使用分布式锁进行调度。防止多个线程同时做相同的操作浪费系统资源(毕竟是大 sql,要尽量避免不必要的请求穿透到数据库)。

  首先实现分布式锁,通过 SETNX 结合 LUA 实现:

public interface RedisLockUtil {
    //加锁
    public boolean lock(String key, String requestId) throws Exception;

    //解锁
    public boolean unlock(String key, String requestId) throws Exception;
}

  实现:

public class ProtoRedisLockUtil implements RedisLockUtil {

    public ProtoRedisLockUtil(StringRedisTemplate redisTemplate, int cacheTime) {
        this.redisTemplate = redisTemplate;
        this.cacheTime = cacheTime;
    }

    private StringRedisTemplate redisTemplate;
    //缓存存活时间
    private int cacheTime;
    //Key 的前缀
    private String preText = "RedisLock|";

    /**
     * @Author
     * @Date 2021/9/27 上午12:11
     * @Description 缓存格式:过期时间的时间戳|请求唯一标识
     * 通过 SETNX 模拟 getAndSet
     * 通过 LUA 脚本保证 "删除过期锁、上锁" 这一对操作的原子性
     */
    @Override
    public boolean lock(String key, String requestId) throws InterruptedException {
        key = preText + key;
        int tryCount = 3;
        while (tryCount > 0) {
            long currentTime = System.currentTimeMillis();
            //缓存存活的最终时间
            Long overdueTime = currentTime + this.cacheTime;
            String val = overdueTime + "|" + requestId;
            //竞争到锁
            if (redisTemplate.opsForValue().setIfAbsent(key, val)) {
                System.out.println("竞争锁成功!");
                return true;
            }
            //LUA 脚本,删除成功返回 1 ,失败返回 0;SET 成功返回 OK;GET 成功返回值,GET 失败返回 null
            StringBuilder USER_AIMS_GOLD_LUA = new StringBuilder();
            USER_AIMS_GOLD_LUA.append("local value = redis.call('get',KEYS[1]);");
            USER_AIMS_GOLD_LUA.append("if not value then return '-1'; end;");
            USER_AIMS_GOLD_LUA.append("local position = string.find(value,'|');");
            USER_AIMS_GOLD_LUA.append("local timeStemp = string.sub(value,0,position-1)");
            USER_AIMS_GOLD_LUA.append("timeStemp = tonumber(timeStemp)");
            USER_AIMS_GOLD_LUA.append("local currentTime = tonumber(ARGV[1])");
            USER_AIMS_GOLD_LUA.append("if currentTime>timeStemp then redis.call('del',KEYS[1]);");
            USER_AIMS_GOLD_LUA.append("if redis.call('setnx', KEYS[1], ARGV[2])==1 then return '1'; " +
                    "else return '0';end;");
            USER_AIMS_GOLD_LUA.append("else return '0';end;");
            DefaultRedisScript defaultRedisScript = new DefaultRedisScript();
            defaultRedisScript.setScriptText(USER_AIMS_GOLD_LUA.toString());
            defaultRedisScript.setResultType(String.class);
            List<String> keyList = new ArrayList();
            keyList.add(key);
            Object result = redisTemplate.execute(defaultRedisScript, keyList, String.valueOf(currentTime),
                    val);
            //删除过期锁并竞争锁成功
            if ("1".equals(result.toString())) {
                System.out.println("删除过期锁并竞争锁成功!");
                return true;
            }
            //未竞争到锁,检查当前锁是否已到期。防止死锁
            tryCount--;
            Thread.sleep(200);
        }
        System.out.println("竞争锁失败!");
        return false;
    }

    /**
     * @Author
     * @Date 2021/9/26 下午10:48
     * @Description 释放锁
     * 通过 LUA 脚本保证 "核对 uuid 、释放锁" 这一对动作的原子性
     */
    @Override
    public boolean unlock(String key, String requestId) {
        key = preText + key;
        StringBuilder USER_AIMS_GOLD_LUA = new StringBuilder();
        USER_AIMS_GOLD_LUA.append("local value = redis.call('get',KEYS[1]);");
        USER_AIMS_GOLD_LUA.append("if not value then return '-1'; end;");
        USER_AIMS_GOLD_LUA.append("local position = string.find(value,'|');");
        USER_AIMS_GOLD_LUA.append("local requestId = string.sub(value,position+1)");
        USER_AIMS_GOLD_LUA.append("if ARGV[1]==requestId then ");
        USER_AIMS_GOLD_LUA.append("redis.call('del',KEYS[1]);return '1';");
        USER_AIMS_GOLD_LUA.append("else return '0'; end;");
        DefaultRedisScript defaultRedisScript = new DefaultRedisScript();
        defaultRedisScript.setScriptText(USER_AIMS_GOLD_LUA.toString());
        defaultRedisScript.setResultType(String.class);
        List<String> keyList = new ArrayList();
        keyList.add(key);
        Object result = redisTemplate.execute(defaultRedisScript, keyList, requestId);
        if ("1".equals(result)) System.out.println("自行释放锁成功");
        return "1".equals(result);
    }
}

  缓存相关操作通过 AOP 织入业务代码,切面实现:

@Aspect
@Component
public class RedisCacheAspect {
    private static final Logger logger = Logger.getLogger(RedisCacheAspect.class);
    //分隔符
    private static final String DELIMITER = "|";
    //默认缓存存活时间,单位:分钟
    private static final int defaultCacheTime = 60;

    @Resource
    RedisTemplate<String, Object> redisTemplate;

    @Resource
    StringRedisTemplate stringRedisTemplate;

    //异步任务池
    @Autowired
    private ThreadPoolExecutor poolExecutor;

    //切点
    @Pointcut("@annotation(com.inspur.redisCache.annotation.RedisCache)")
    public void redisCacheAspect() {
    }

    //切面
    @Around("redisCacheAspect()")
    public Object cache(ProceedingJoinPoint joinPoint) {
        String clazzName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        String key = this.getRedisKey(clazzName, methodName, args);
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        //注解配置
        int cacheTimeMin = method.getAnnotation(RedisCache.class).cacheTime();
        boolean refreshCacheWithSelect = method.getAnnotation(RedisCache.class).refreshWithSelect();
        Object cacheValue = redisTemplate.boundValueOps(key).get();
        //缓存命中
        if (cacheValue != null) {
            logger.info("Redis 缓存命中:" + key);
            // 若缓存命中时也需更新缓存,提交异步任务
            if (refreshCacheWithSelect) poolExecutor.execute(new CacheTask(joinPoint, cacheTimeMin, key));
            return cacheValue;
        }
        //缓存未命中
        Object res = this.selectAndCache(joinPoint, cacheTimeMin, key);
        return res;
    }

    /**
     * @Author
     * @Date 2021/9/26 上午10:29
     * @Description 更新缓存异步任务
     */
    private class CacheTask implements Runnable {
        ProceedingJoinPoint joinPoint;
        String key;
        int cacheTime;

        CacheTask(ProceedingJoinPoint joinPoint, int cacheTime, String key) {
            this.joinPoint = joinPoint;
            this.cacheTime = cacheTime <= 0 ? 60 : cacheTime;
            this.key = key;
        }

        @Override
        public void run() {
            selectAndCache(this.joinPoint, this.cacheTime, this.key);
        }
    }

    /**
     * @Author
     * @Date 2021/9/26 上午10:43
     * @Description 查询并更新缓存
     */
    private Object selectAndCache(ProceedingJoinPoint joinPoint, int cacheTime, String key) {
        Object res = null;
        try {
            if (key == null || key.length() == 0) throw new NullPointerException("传入的 key 为空!");
            String uuid = UUID.randomUUID().toString();
            RedisLockUtil redisLock = new ProtoRedisLockUtil(stringRedisTemplate, 30000);
            //竞争分布式锁,防止短时间同时处理大量重复请求
            if (redisLock.lock(key, uuid)) {
                Object[] args = joinPoint.getArgs();
                res = joinPoint.proceed(args);
                if (res == null) throw new RuntimeException(key + "查询结果为空!");
                redisTemplate.opsForValue().set(key, res, Long.valueOf(cacheTime), TimeUnit.MINUTES);
                redisLock.unlock(key, uuid);
            }
        } catch (Throwable e) {
            logger.error("Redis 更新缓存异步任务异常:" + e.getMessage(), e);
        }
        return res;
    }

    /**
     * @Author
     * @Date 2021/9/26 上午10:47
     * @Description 计算 Redis 中的 Key
     */
    private String getRedisKey(String clazzName, String methodName, Object[] args) {
        StringBuilder key = new StringBuilder(clazzName);
        key.append(DELIMITER);
        key.append(methodName);
        key.append(DELIMITER);
        for (Object obj : args) {
            if (obj == null) continue;
            key.append(obj.getClass().getSimpleName());
            //参数不是基本数据类型时会缓存失效 TO-DO
            key.append(obj.toString());
            key.append(DELIMITER);
        }
        return key.toString();
    }

}

  切入点选择注解方式(使用灵活),自定义注解:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedisCache {
    //缓存存活时间,单位:分钟
    int cacheTime() default 60;

    //是否缓存命中时也更新缓存,提高缓存命中率
    boolean refreshWithSelect() default false;
}

  最终使用:

 @RedisCache(cacheTime = 30, refreshWithSelect = true)
  public List<Object> me(String param) throws Exception {
     //正常查询数据库的业务代码  
 }

 

标签:缓存,String,GOLD,Redis,AIMS,LUA,织入,USER,AOP
来源: https://www.cnblogs.com/niuyourou/p/15345870.html