Java接口防重复提交

最新推荐文章于 2024-06-19 09:15:34 发布

dylan1iu

最新推荐文章于 2024-06-19 09:15:34 发布

阅读量2.5k

点赞数 3

分类专栏： Redis Java 文章标签： redis java

本文链接：https://blog.csdn.net/biubiu2it/article/details/113570736

版权

Java 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

Redis

1 篇文章 0 订阅

订阅专栏

背景

业务系统中的防重复提交都是由前端控制，后端在某些地方做了相应的业务逻辑相关的判断，但当某些情况下，前后端的判断都会失效，所以这里引入后端的接口防重复提交校验。

方案

由于需要限制的是部分接口，因此使用AOP+注解+Redis的方式来实现。AOP+注解的方式更加灵活，在需要限制的接口上加上注解即可。Redis则可以使防重复提交在分布式系统中使用。由于业务的特殊性，需要实现：1.同一个用户不能重复访问同一个接口；2.不同的用户不能以相同的参数同时访问同一个接口

实现

1.定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatSubmitVerify {
    /**
     * 设置请求锁定时间，单位：秒
     *
     * @return
     */
    int lockTime() default 10;

    /**
     * 参数名称
     *
     * @return
     */
    String paramString();
}

2.定义切面

@Aspect
@Component
@Slf4j
public class RepeatSubmitAspect {

    @Autowired
    private RedisLock redisLock;

    @Pointcut("@annotation(repeatSubmitVerify)")
    public void pointCut(RepeatSubmitVerify repeatSubmitVerify) {
    }

    @Around("pointCut(repeatSubmitVerify)")
    public Object around(ProceedingJoinPoint pjp, RepeatSubmitVerify repeatSubmitVerify) throws Throwable {
        int lockSeconds = repeatSubmitVerify.lockTime();

        String param = "{}";
        if (StringUtils.isNotBlank(repeatSubmitVerify.paramString())) {
            param = getKey(repeatSubmitVerify.paramString(), pjp);
        }

        JSONObject paramJson = JSON.parseObject(param);
        String token = paramJson.getString("token");

        // 这里需要设置两个lockKey，分别实现两个目的
        String key_prefix = pjp.getSignature().getDeclaringType().getSimpleName() + "_";
        // 接口名称+请求参数，避免不同的用户以相同的参数访问同时访问同一个接口
        String key1 = key_prefix + DigestUtils.md5Hex(paramJson.toJSONString());
        // 接口名称+用户token，避免同一个用户重复访问同一个接口
        String key2 = key_prefix + DigestUtils.md5Hex(token);
        // 上锁与解锁应该由同一个线程来执行，而不能其他线程来执行解锁，否则可能会出现错误解锁
        String clientId = getClientId();

		// 上锁
        Boolean isSuccess = redisLock.tryLock(key1, key2, clientId, lockSeconds);
        Assert.notNull(isSuccess, "系统访问校验异常");
        if (isSuccess) {
            log.info("tryLock success, key1 = [{}], key2 = [{}], clientId = [{}]", key1, key2, clientId);
            // 获取锁成功
            Object result;

            try {
                // 执行进程
                result = pjp.proceed();
            } finally {
                // 解锁
                Boolean releaseLock = redisLock.releaseLock(key1, key2, clientId);
                log.info("releaseLock success, key1 = [{}], key2 = [{}], clientId = [{}], result = [{}]", key1, key2, clientId, releaseLock);
            }

            return result;

        } else {
            // 获取锁失败，认为是重复提交的请求
            
            // 解锁这一步可以省略，在最终方案确定之前，上两把锁是分两步进行的，
            // 这样就会在重复请求时，其中一把上锁成功，而另一把不成功，判定上锁是失败的，
            // 因此要将成功的一把锁进行解锁，需要执行以下步骤
            // 而最终方案是通过lua脚本执行，要么成功上锁，两把锁都成功，要么失败，两把锁都失败，所以这一步可以省略
            Boolean releaseLock = redisLock.releaseLock(key1, key2, clientId);
            log.info("releaseLock success, key1 = [{}], key2 = [{}], clientId = [{}], result = [{}]", key1, key2, clientId, releaseLock);
            
            return errorData("操作已受理，请勿重复操作！");
        }

    }
	//获取请求参数
    private String getKey(String key, JoinPoint joinPoint) {
        Method method = ((MethodSignature) (joinPoint.getSignature())).getMethod();
        String[] paramenterNames = new LocalVariableTableParameterNameDiscoverer().getParameterNames(method);
        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression(key);
        EvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        if (args.length <= 0) {
            return "";
        }
        for (int i = 0; i < args.length; i++) {
            context.setVariable(paramenterNames[i], args[i]);
        }
        return expression.getValue(context, String.class);
    }
	//获取每一次访问的UUID
    private String getClientId() {
        return UUID.randomUUID().toString();
    }
}

@Service
@Slf4j
public class RedisLock {
	//lua脚本中的返回值判断需要特别注意
    private static final String RELEASE_LOCK_SCRIPT = "local p1 local p2 if redis.call('get', KEYS[1]) == KEYS[3] then p1 = redis.call('del', KEYS[1]) else p1 = 1 end if redis.call('get', KEYS[2]) == KEYS[3] then p2 = redis.call('del', KEYS[2]) else p2 = 1 end return p1~=0 or p2~=0";
    private static final String TRY_LOCK_SCRIPT = "if redis.call('exists', KEYS[1]) == 1 or redis.call('exists', KEYS[2]) == 1 then return 0 else redis.call('setex', KEYS[1], KEYS[4], KEYS[3]) redis.call('setex', KEYS[2], KEYS[4], KEYS[3]) return 1 end";
  
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 该加锁方法仅针对单实例 Redis 可实现分布式加锁
     * 对于 Redis 集群则无法使用
     * <p>
     * 支持重复，线程安全
     *
     * @param lockKey1 加锁键
     * @param lockKey2 加锁键
     * @param clientId 加锁客户端唯一标识(采用UUID)
     * @param seconds  锁过期时间
     * @return
     */
    public Boolean tryLock(String lockKey1, String lockKey2, String clientId, long seconds) {
        try {
            Boolean result = redisTemplate.execute(new DefaultRedisScript<>(TRY_LOCK_SCRIPT, Boolean.class), Arrays.asList(lockKey1, lockKey2, clientId, String.valueOf(seconds)));
            log.info("tryLock, lockKey1 = [{}], lockKey2 = [{}], result = [{}], lockVal1 = [{}], lockVal2 = [{}]", lockKey1, lockKey2, result, redisTemplate.opsForValue().get(lockKey1), redisTemplate.opsForValue().get(lockKey1));
            return result;
            // return redisTemplate.opsForValue().setIfAbsent(lockKey1, clientId, seconds, TimeUnit.SECONDS)
            //         && redisTemplate.opsForValue().setIfAbsent(lockKey2, clientId, seconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 与 tryLock 相对应，用作释放锁
     *
     * @param lockKey1
     * @param lockKey2
     * @param clientId
     * @return
     */
    public Boolean releaseLock(String lockKey1, String lockKey2, String clientId) {
        try {
            return redisTemplate.execute(new DefaultRedisScript<>(RELEASE_LOCK_SCRIPT, Boolean.class), Arrays.asList(lockKey1, lockKey2, clientId));
        } catch (Exception e) {
            log.error("{}", e);
            return false;
        }
    }

3.在需要处理的接口上打注解

参考资料

Redis eval命令踩得那些坑：https://github.com/nethibernate/blog/issues/7
Redis分布式锁的正确实现方式：https://www.cnblogs.com/linjiqin/p/8003838.html
CentOS7 安装lua环境：https://blog.csdn.net/houjixin/article/details/46634847
参考Github代码仓库：https://github.com/MissDistin/repeat-submit-intercept