原创 嘉森 date 2019-12-09
1、为什么要防重
服务端提供的一些接口，并不具备幂等性，比如创建订单等。
除了脚本恶意刷单外，在某些特殊情况下，如遇到网络延迟，用户也会习惯性多次点击提交按钮，会发生相同表单被重复提交，导致后端数据异常，如订单重复创建等情况，同时还会造成服务端调用资源浪费。
因此，有必要对表单提交进行防重操作。
2、防重方案
常见的防重方案可归为三类：前端防重、服务端防重和数据库防重。以下例举了这三类防重方案的实现方法，并对其优缺点进行简析。
2.1、前端防重
2.1.1 JS防重
在提交同时，设定一个flag值，如is_commit=true/false。在提交前，通过该flag确定此次表单是否可以提交
2.1.2 css禁止点击
在用户点击提交后，将点击按钮css属性设置为disable，此时用户不可再次点击按钮进行提交
优点
- 实现简单
缺点
- 某些对于后端服务的请求，发生在页面加载阶段，无法避免频繁刷新页面产生的重复提交
- 无法防止用户通过前端脚本发起的恶意请求
2.2、服务端
2.2.1 后端重定向
在用户发起表单提交后，进行后端重定向，跳转到新的页面，防止重复请求
优点
- 实现简单
缺点
- 对表单提交时的瞬时重复点击无法预防
- 局限性大，对于页面中发起的Ajax请求，不适合使用重定向
2.2.2 利用session
打开表单页面时，请求后端接口生成一个token并保存于Redis，同时把该token传给表单页面。
当表单提交时会带上该token(cookie或header)，
可以通过拦截器Interceptor拦截该请求，并判断与Redis中保存的token是否一致
session解决重复提交流程
优点
- 适合不能重定向场景
- 能防止表单提交时的重复点击
- 可防范恶意脚本请求
缺点
- 前后端都需要写入一定的逻辑，过于繁琐
2.3、数据库层
2.3.1添加唯一约束
通过将数据表中，具备唯一特性的字段组合，作为唯一约束建立Unique Key，最终依赖数据库的唯一键约束来万完成去重。
优点
- 能充分保证数据的唯一性
- 不用写额外代码
缺点
- 一份数据表，在不同业务场景下，对于满足唯一约束的字段组合，可能是不一致的
- 在高并发场景下，数据库的写入性能会有瓶颈
2.3.2防重表
针对不同业务在一张业务表中，可能具备不同的唯一约束问题，可以通过为具体业务单独建立一张去重表来实现
优点
- 能适合各种场景需求
缺点
- 需要维护额外的表
- 需要保证事务一致性，业务表插入失败时需要回滚
- 增加业务逻辑的复杂性，防重方案扩散到了业务逻辑中
3、我的方案
我们对于重复请求的定义：
a. 对于Service层服务 - 调用方法 + 入参值完全相同的请求，为重复请求
b. 对于Controller层服务 - 调用方法 + 入参值 + cookie值完全相同请求，为重复请求。
对于重复的请求，服务端提供方只需处理其中一个，忽略其他。
防重方案
3.1 特点
- 基于类似锁的方式来实现去重
- 基于Spring AOP实现，在Spring项目中可以方便集成
- 兼容Controller层防重与Service层防重调用
- 支持用户指定具体的参数作为防重规则
- 支持用户选择不同的介质作为防重校验的存储
- 支持用户选择设置防重规则与时间窗口（只防止同时重复提交 / 防止一段时间内相同提交）
3.2 在Spring中集成使用
3.2.1 注册用于去重的bean定义
注册加锁类与切面方法
@Bean
public ARCLock arcLock() {
//使用锁机制进行去重
return new RedisARCLock(jedis);
}
@Bean
public AvoidRepeatableCommitAspect avoidRepeatableCommitAspect() {
//使用切面拦截可能的重复调用
return new AvoidRepeatableCommitAspect();
}
3.2.2 指定需要去重的服务方法
默认调用方式，在需要防重的方法前添加@ARC注解
通过方法签名 + 参数数据作为判重条件
可以过滤重复请求，当距离上一次成功请求超过3s之后，亦可以接受重复请求
@ARC
public String method(Object a, Object b) {
}
支持自定义用于判断重复请求的参数数据，如使用@ARCKey指定参与判重的参数为Object b
@ARC
public String method(Object a, @ARCKey Object b) {
}
支持自定义去重的时间窗口，在时间窗口内，不再接受重复请求
@ARC(expire = 5, timeUnit = TimeUnit.SECONDS, unlock = false)
public String method(Object a, Object b) {
}
3.3 去重方案的具体实现
3.3.1 定义防重注解@ARC
首先定义对应的注解@ARC
@Inherited
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ARC {
/**
* 请求hash后待添加的前缀
*/
String[] prefixKey() default {};
/**
* 防重超时时间
*/
long expire() default 3L;
/**
* 防重超时时间单位
*/
TimeUnit timeUnit() default TimeUnit.SECONDS;
/**
* disable unlock
*/
boolean unlock() default true;
}
为了支持自定义参与去重判断的参数，还需要定义注解@ARCKey
@Inherited
@Target({ ElementType.TYPE, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
public @interface ARCKey {
}
3.3.2 兼容支持Controller层与Service层的去重
在Service层，我们定义调用方法签名 + 关键入参相等的两次调用为重复调用
在Controller层，还需要Cookie信息，因此去重判断的依据为方法签名 + 关键入参 + Cookie数据。
为此，在AOP切面实现时，需要对当前注解标识的对象进行判断和处理
// 如果为Controller层，将request中的cookie也作为防重判断的一部分
if (Objects.nonNull(target.getAnnotation(RestController.class))
|| Objects.nonNull(target.getAnnotation(Controller.class))) {
RequestAttributes ra = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes sra = (ServletRequestAttributes) ra;
HttpServletRequest request = sra.getRequest();
Cookie[] cookies = request.getCookies();
if (cookies != null) {
logger.info(JSON.toJSONString(cookies));
stringJoiner.add(String.valueOf(JSON.toJSONString(cookies).hashCode()));
}
}
3.3.3 生成用于去重的key值
根据定义，将用户本次调用的方法签名+入参等组成key，可以最准确的判断请求是否重复
但是，当用户请求参数过多时，直接组成的key值长度会较大，引起内存浪费、检索慢等问题。
因此，我们对请求进行真实的去重key进行hash，获取真实key的hashCode作为去重依据。
3.3.4 整体实现
@Component
@Aspect
public class AvoidRepeatableCommitAspect {
private static final Logger logger = LoggerFactory.getLogger(AvoidRepeatableCommitAspect.class);
@Autowired
private ARCLock arcLock;
public AvoidRepeatableCommitAspect() {
}
@Pointcut("@annotation(com.xxx.xxx.annotation.ARC)")
public void pointcutARC() {
}
@Around("pointcutARC()")
public Object executeAround(ProceedingJoinPoint jp) throws Throwable {
MethodSignature methodSignature = (MethodSignature) jp.getSignature();
Method method = methodSignature.getMethod();
ARC arc = method.getAnnotation(ARC.class);
String jpArgsString = getArgsString(jp.getArgs(), method);
String key = generateKey(jp, method, arc.prefixKey(), jpArgsString);
boolean getLock = false;
try {
getLock = arcLock.trylock(key, arc.expire(), arc.timeUnit());
if (!getLock) {
logger.error("{} commit repeat, args is {} try setNX error", key, jpArgsString);
throw new ARCException("commit repeat");
}
return jp.proceed();
} finally {
if (getLock && arc.unlock()) {
arcLock.unLock(key);
}
}
}
/**
* 根据className.methodName.prefix.hash(args) 生成key，在controller层时，后缀再添加.[hash(cookie)]
* @param jp jp
* @param method 调用的方法
* @param prefixKeyList key前缀
* @param jpArgsString 传参
*/
private String generateKey(ProceedingJoinPoint jp, Method method, String[] prefixKeyList, String jpArgsString) {
Class<?> target = jp.getTarget().getClass();
String className = target.getName();
String methodName = method.getName();
StringJoiner stringJoiner = new StringJoiner(".");
for (String prefixKey: prefixKeyList) {
stringJoiner.add(prefixKey);
}
stringJoiner.add(className);
stringJoiner.add(methodName);
stringJoiner.add(String.valueOf(JSON.toJSONString(jpArgsString).hashCode()));
// 如果为Controller层，将request中的cookie也作为防重判断的一部分
if (Objects.nonNull(target.getAnnotation(RestController.class))
|| Objects.nonNull(target.getAnnotation(Controller.class))) {
RequestAttributes ra = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes sra = (ServletRequestAttributes) ra;
HttpServletRequest request = sra.getRequest();
Cookie[] cookies = request.getCookies();
if (cookies != null) {
logger.info(JSON.toJSONString(cookies));
stringJoiner.add(String.valueOf(JSON.toJSONString(cookies).hashCode()));
}
}
return stringJoiner.toString();
}
/**
* 筛选需要作为key的传参，默认传参全部为key组成部分
* @param args
* @param method
*/
private String getArgsString(Object[] args, Method method) {
Parameter[] parameters = method.getParameters();
List<Object> params = new ArrayList<>();
List<Object> keyParams = new ArrayList <>();
boolean havARCKey = false;
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
ARCKey arcKey = parameter.getAnnotation(ARCKey.class);
if (arcKey != null) {
havARCKey = true;
keyParams.add(args[i]);
}
params.add(args[i]);
}
return JSON.toJSONString(havARCKey ? keyParams : params);
}
}
3.4 方案的可扩展性
本质上讲，本去重方案使用了类似锁的实现思路
对于锁的实现思路，一般需要使用一个用于判重的存储，如Redis，同时该存储最好还要具备定时过期的时间窗口能力，如Redis的expire
常见的如Redis、Zookeeper等，都可以作为选择
为了能兼容不同的存储介质，这里基于facade模式的设计思路，将加锁/解锁操作作为接口提取了出来
支持用户根据实际使用的存储，来实现去重功能
本方案也是基于Redis，实现了接口中的trylock和unlock方法，从而实现去重的功能
public class RedisARCLock implements ARCLock {
static volatile Jedis jedis;
private static final Logger logger = LoggerFactory.getLogger(RedisARCLock.class);
public RedisARCLock(Jedis jedis) {
if (Objects.isNull(this.jedis)) {
synchronized (RedisARCLock.class) {
if (Objects.isNull(this.jedis)) {
this.jedis = jedis;
}
}
}
}
/**
* 尝试获取锁
* @param key
* @param timeout
* @param unit
*/
public boolean tryLock(String key, Long expire, TimeUnit unit ) {
byte[] rawKey = SerializationUtils.serialize(key, new DefaultStringSerializer());
byte[] rawValue = SerializationUtils.serialize("lock", new DefaultStringSerializer());
TransactionClient tc=redisClient.transactionClient(rawKey);
Transaction tc = jedis.multi();
tc.multi();
tc.setnx(rawKey, rawValue);
tc.expire(rawKey, unit.toSeconds(expire));
List<Object> execList= tc.exec();
if (null == execList || 0 >= execList.size()) {
return false;
}
List<Boolean> resList = (ArrayList<Boolean>) execList.get(0);
return Boolean.valueOf(resList.get(0));
}
/**
* 根据key值删除缓存内容
*
* @param key key值
*/
public void unLock(String key) {
try {
jedis.del(key);
} catch (Exception e) {
logger.error("Redis删除Key:{}异常", key, e);
}
}
}
