接口限流处理

1.为什么要限流

当我们设计接口时，需要考虑的因素有很多，其中例如如在设计获取短信验证码的接口时，第一个想到的就是，接口如何去实现访问控制，好比如我只能让你1分钟之内最多请求1次，或者其他规则，这样很大程度上对接口起到一定的保护。防止对接口的恶意请求，减少不必要的资源浪费。当然并非所有接口都需要做这些限制，这也需要根据实际业务而定。

2.怎么限流

基于springboot而言，我们想到的是通过redis的自加：incr来实现。我们可以通过用户的唯一标识来设计成redis的key,值为单位时间内用户的请求次数。

3.实现

基于，是什么，为什么，怎么做三部曲，闲话不多说，直接上代码。

/**
*  注解用户访问控制
 * 在 second 秒内，最大只能请求 maxCount 次
 * @author Json
 * @date 2022/3/9 19:33
 */
@Documented
@Inherited
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {
    /**
     * 通过redis 实现的 这里指定redisKey 否则默认用户id标识 做实现
     */
    String redisKey();

    /**
     * 时间
     */
    int second() default 1;

    /**
     * 最大请求量
     */
    int maxCount() default 1;

    /**
     * 错误文案
     */
    String errorMsg();
}

再写个拦截器

@Slf4j
@Component
public class RequestLimitIntercept implements HandlerInterceptor {
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public boolean preHandle(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler) throws Exception {

        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        //HandlerMethod 封装方法定义相关的信息,如类,方法,参数等
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        // 获取方法中是否包含注解
        RequestLimit methodAnnotation = method.getAnnotation(RequestLimit.class);
        //获取 类中是否包含注解，也就是controller 是否有注解
        RequestLimit classAnnotation = method.getDeclaringClass().getAnnotation(RequestLimit.class);
        // 如果 方法上有注解就优先选择方法上的参数，否则类上的参数
        RequestLimit requestLimit = methodAnnotation != null ? methodAnnotation : classAnnotation;
        if (requestLimit != null) {
            if (isLimit(request, requestLimit)) {
                Result<String> result = new ResultUtil<String>().setErrorMsg(requestLimit.errorMsg());
                response.getWriter().write(JSONObject.toJSON(result).toString());
                return false;
            }
        }

        return true;
    }

    /**
     * 判断请求是否受限
     *
     * @param request      HttpServletRequest
     * @param requestLimit RequestLimit
     * @return true 允许  false 不允许
     */
    public boolean isLimit(HttpServletRequest request, RequestLimit requestLimit) {
        // 受限的redis 缓存key ,因为这里用浏览器做测试，我就用sessionid 来做唯一key,如果是app ,可以使用 用户ID 之类的唯一标识。
        String redisKey = requestLimit.redisKey();
        String limitKey;
        if (StringUtils.isNotBlank(redisKey)) {
            limitKey = redisKey;
        }else {
            limitKey = request.getServletPath() + request.getSession().getId();
        }
        // 从缓存中获取，当前这个请求访问了几次
        Object obj = redisTemplate.opsForValue().get(limitKey);
        if (obj == null) {
            //初始 次数
            redisTemplate.opsForValue().set(limitKey, "1", requestLimit.second(), TimeUnit.SECONDS);
        } else {
            if (Integer.parseInt(String.valueOf(obj)) >= requestLimit.maxCount()) {
                return true;
            }
            // 次数自增 +1
            redisTemplate.opsForValue().increment(limitKey);
        }
        return false;
    }

}

再接口上我们加上上面的注解，即可实现单位时间内的访问控制，当然这里只说了大概的原理，可以自行根据业务去改造，当然还有其他办法去实现类似的效果，只是redis做起来会更方便，更好。