java 分布式重复提交_Java接口防重复提交

最新推荐文章于 2024-07-02 11:26:55 发布

星落樱耀

最新推荐文章于 2024-07-02 11:26:55 发布

阅读量338

点赞数

文章标签： java 分布式重复提交

本文链接：https://blog.csdn.net/weixin_42470359/article/details/114949575

版权

背景

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

方案

由于需要限制的是部分接口，因此使用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 RedisTemplate redisTemplate;

/**

* 该加锁方法仅针对单实例 Redis 可实现分布式加锁

* 对于 Redis 集群则无法使用

* 支持重复，线程安全

* @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