1.什么是接口防重?
在一定的时间内多次请求同一接口,同一参数。由于请求是健康请求
,会执行正常的业务逻辑
,从而产生大量的废数据。
2.问题的产生及引发的问题
举一个最简单的例子:日常开发中crud在业务系统中普遍存在,在服务端没有做任何处理,客户端没有做节流、防抖
等限流操作时,同一秒一个用户点了两次新增按钮,导致数据库中存在同样两条数据,其结果可想而知,同理修改、删除同样的道理;查询本身具有幂等性
,但是在同一秒钟同样的操作,查询多次和一次,有区别吗?区别大了去了,不谈用户体验如何,光是网络开销、流量占用、带给服务器的压力
等等,生产中一点小的问题,如何不及时处理,可能会引发灾难性bug。
3.处理方法
-
第一种:前台在请求接口的时候,传递一个唯一值,然后在对应接口判断该唯一值,在一定的时间内是否被消费过
-
第二种:采用
Spring AOP
理念,实现请求的切割,在请求执行到某个方法或某层时候,开始拦截进行,获取该请求的参数,用户信息,请求地址,存入redis中并放置过期时间,进行防重(推荐使用)
4.谈谈以下两种处理方法的利弊
- 第一种:局限性太高,前台必须传递一个唯一值,就算请求到达指定后台服务,写一个拦截器,需要配置太多不需要拦截的方法,也许你会说,可以拦截有规则的请求地址,这样真的好吗?
- 第二种(推荐):采用
AOP面向切面编程的思想
,在不污染源代码的情况下,进行增强功能,切入到要防重的接口上,实现统一防重处理、业务解耦。此处采用AOP + 自定义注解
,灵活实现防重功能。
5.具体代码(采用第二种)
注解类
import java.lang.annotation.*;
/**
* 防重
* @date 2020/8/12
* @return
*/
//标识该注解用于方法上
@Target({ElementType.METHOD})
//申明该注解为运行时注解,编译后改注解不会被遗弃
@Retention(RetentionPolicy.RUNTIME)
//javadoc工具记录
@Documented
public @interface PreventSubmit
{
}
切面类
import com.qianxian.common.exception.AppException;
import com.qianxian.common.util.TokenUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
/**
* 防重复提交
* @date 2020/8/12
* @return
*/
@Component
@Aspect
@Slf4j
public class PreventSubmitAspect {
/**
* 放重redis前缀
*/
private static String API_PREVENT_SUBMIT = "api:preventSubmit:";
/**
* 放重分布式锁前缀
*/
private static String API_LOCK_PREVENT_SUBMIT = "api:preventSubmit:lock:";
/**
* 失效时间
*/
private static Integer INVALID_NUMBER = 3;
/**
* redis
*/
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 分布式锁
*/
@Autowired
private RedissonClient redissonClient;
/**
* 防重
* @date 2020/8/12
* @return
*/
@Around("@annotation(com.qianxian.user.annotation.PreventSubmit)")
public Object preventSubmitAspect(ProceedingJoinPoint joinPoint) throws Throwable {
RLock lock = null;
try {
//获取目标方法的参数
Object[] args = joinPoint.getArgs();
//获取当前request请求
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
//获取请求地址
String requestUri = request.getRequestURI();
//获取用户ID
Long userId = null;
try {
userId = TokenUtil.getUserId(request);
}catch (Exception e){}
//拼接锁前缀,采用同一方法,同一用户,同一接口
String temp = requestUri.concat(Arrays.asList(args).toString()) + (userId != null ? userId : "");
temp = temp.replaceAll("/","");
//拼接rediskey
String lockPrefix = API_LOCK_PREVENT_SUBMIT.concat(temp);
String redisPrefix = API_PREVENT_SUBMIT.concat(temp);
/**
* 对同一方法同一用户同一参数加锁,即使获取不到用户ID,每个用户请求数据也会不一致,不会造成接口堵塞
*/
lock = this.redissonClient.getLock(lockPrefix);
lock.lock();
String flag = this.stringRedisTemplate.opsForValue().get(redisPrefix);
if(StringUtils.isNotEmpty(flag)){
throw new AppException("您当前的操作太频繁了,请稍后再试!");
}
//存入redis,设置失效时间
this.stringRedisTemplate.opsForValue()
.set(redisPrefix,redisPrefix,INVALID_NUMBER, TimeUnit.SECONDS);
//执行目标方法
Object result = joinPoint.proceed(args);
return result;
}finally {
if(lock != null){
lock.unlock();
}
}
}
}