背景
业务系统中的防重复提交都是由前端控制，后端在某些地方做了相应的业务逻辑相关的判断，但当某些情况下，前后端的判断都会失效，所以这里引入后端的接口防重复提交校验。
方案
由于需要限制的是部分接口，因此使用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 集群则无法使用
* <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