redisson与aop解决接口幂等性

缺乏、安全感 2023-10-06 13:45 31阅读 0赞

**实现思路：**

1.自定义防重复提交的注解和切面
    
    2.在需要验证的接口上增加注解（一般是创建、修改的接口）
    
    3.以每次调用的 用户唯一标识（userId或者sessionId或者token）+ 请求路径+参数 作为key，value任意值都可以，缓存起来（redis或本地缓存），并设置一个合适的缓存失效时间。
    
    4.每次调用时根据key判断，缓存是否存在，存在则抛出异常或提示，不存在则执行业务逻辑

**声明自定义注解：**

package com.***.annotation;
    
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * <p>Description: [防重复提交注解]</p >
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface NoRepeatSubmit {
    
        /**
         * 过期时长（毫秒）
         *
         * @return
         */
        long expire() default 500;
    
    }

**使用redissionClient实现分布式锁（可重入锁）：**

package com.***.util;
    
    import lombok.extern.slf4j.Slf4j;
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    
    import java.util.concurrent.TimeUnit;
    import java.util.function.Supplier;
    
    @Slf4j
    public class RedisLock {
    
        /**
         * 默认等待时长 1 毫秒
         */
        private static final long DEF_WAIT_TIME = 1L;
    
        /**
         * 默认过期时长 10 秒
         */
        private static final long DEF_EXPIRE_TIME = 1000 * 10L;
    
        /**
         * 默认重试次数
         */
        private static final Integer NO_TRY_COUNT = 0;
        /**
         * 默认重试休眠时长
         */
        private static final Long NO_TRY_SLEEP_TIME = 0L;
    
        private RedisLock() {
        }
    
        /**
         * 获取分布式锁
         *
         * @param redissonClient
         * @param lockKey        锁标识
         * @return
         */
        public static RLock getLock(RedissonClient redissonClient, String lockKey) {
            return redissonClient.getLock(lockKey);
        }
    
        /**
         * 尝试加锁
         *
         * @param lock 锁
         * @return
         */
        public static boolean lock(RLock lock) {
            return lock(lock, null);
        }
    
        /**
         * 尝试加锁
         *
         * @param lock       锁
         * @param conditions 附加条件
         * @return
         */
        public static boolean lock(RLock lock, Supplier<Boolean> conditions) {
            return lock(lock, NO_TRY_COUNT, NO_TRY_SLEEP_TIME, conditions);
        }
    
        /**
         * 尝试加锁
         *
         * @param lock       锁
         * @param tryCount   重试次数
         * @param sleepTime  重试休眠时长（毫秒）
         * @param conditions 附加条件
         * @return
         */
        public static boolean lock(RLock lock, int tryCount, long sleepTime, Supplier<Boolean> conditions) {
            return lock(lock, DEF_WAIT_TIME, DEF_EXPIRE_TIME, tryCount, sleepTime, conditions);
        }
    
        /**
         * 尝试加锁
         *
         * @param lock       锁
         * @param waitTime   获取锁等待时长（毫秒）
         * @param expireTime 获取锁后自动过期时长（毫秒）
         * @param tryCount   重试次数
         * @param sleepTime  重试休眠时长（毫秒）
         * @param conditions 附加条件
         * @return
         */
        public static boolean lock(RLock lock, long waitTime, long expireTime, int tryCount,
                                   long sleepTime, Supplier<Boolean> conditions) {
            boolean result = false;
            try {
                boolean unlock = lock.tryLock(waitTime, expireTime, TimeUnit.MILLISECONDS);
                log.info("======> " + Thread.currentThread() + "尝试{}获取锁{} -> {}", tryCount, lock.getName(), unlock);
                if (unlock) {
                    if (null != conditions) {
                        result = conditions.get();
                    } else {
                        result = true;
                    }
                } else {
                    while (tryCount > 0) {
                        Thread.sleep(sleepTime);
                        --tryCount;
                        boolean res = lock(lock, waitTime, expireTime, tryCount, sleepTime, conditions);
                        if (res) {
                            result = true;
                            break;
                        }
                    }
                }
            } catch (InterruptedException e) {
                log.error("RedisLock 获取分布式锁异常 -> {}", e);
                Thread.currentThread().interrupt();
            }
            return result;
        }
    
        /**
         * 释放锁
         *
         * @param lock
         */
        public static void unlock(RLock lock) {
            if (null != lock) {
                log.info("<====== " + Thread.currentThread() + "释放锁{}", lock.getName());
                lock.unlock();
            }
        }
    
    }

**注解处理实现类：**

package com.***.annotation;
    
    import com.***.MD5Util;
    import com.***.CacheKeyBuild;
    import com.***.CacheService;
    import com.***.ResultCodeEnum;
    import com.***.RedisLock;
    import com.***.ServiceException;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Arrays;
    import java.util.Optional;
    import java.util.concurrent.TimeUnit;
    
    @Aspect
    @Component
    @Slf4j
    public class NoRepeatSubmitAop {
    
        private static final String TOKEN_KEY = "Authorization";
    
        @Autowired
        private CacheService cacheService;
    
        @Autowired
        private RedissonClient redissonClient;
    
        @Pointcut("@annotation(com.asp.alc.prepose.annotation.NoRepeatSubmit)")
        public void serviceNoRepeat() {
            // 这是一个标记方法
        }
    
        @Around("serviceNoRepeat()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            HttpServletRequest request =((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String token = request.getHeader(TOKEN_KEY);
            String url = request.getRequestURL().toString();
            String params = Arrays.toString(pjp.getArgs());
            String key =  CacheKeyBuild.buildSysAccountKey(MD5Util.MD(token + "-" + url + "-" + params));
            // 这里使用分布锁保证其线程安全（这里很关键）
            String lockKey = "Lock-" + key;
            RLock lock = RedisLock.getLock(redissonClient, lockKey);
            boolean res = RedisLock.lock(lock);
            if(!res) {
                throw new ServiceException(ResultCodeEnum.CODE_10007.code, ResultCodeEnum.CODE_10007.desc);
            }
            Optional<String> cacheValue = Optional.ofNullable(cacheService.getString(key));
            log.info("======> " + Thread.currentThread() + "NoRepeatSubmitAop {} -> {}", key, cacheValue.isPresent());
            if (!cacheValue.isPresent()) {
                try {
                    Object o = pjp.proceed();
                    MethodSignature signature = (MethodSignature) pjp.getSignature();
                    NoRepeatSubmit noRepeatSubmit = signature.getMethod().getAnnotation(NoRepeatSubmit.class);
                    // 默认500毫秒内同一认证用户同一个地址同一个参数，视为重复提交
                    cacheService.set(key, "******", noRepeatSubmit.expire(), TimeUnit.MILLISECONDS);
                    return o;
                }catch (ServiceException e){
                    log.error(e.getMessage(), e);
                    throw e;
                }catch (Exception e){
                    log.error(ResultCodeEnum.CODE_10000.desc, e);
                    throw new ServiceException(ResultCodeEnum.CODE_10000.code, e.getMessage());
                } finally {
                    RedisLock.unlock(lock);
                }
            } else {
                RedisLock.unlock(lock);
                throw new ServiceException(ResultCodeEnum.CODE_10007.code, ResultCodeEnum.CODE_10007.desc);
            }
        }
    
    }