Guava-RateLimiter实现令牌桶控制接口限流方案（注解方式）

常见限流方案

1.计数器法

• 原理：在单位时间段内，对请求数进行计数，如果数量超过了单位时间的限制，则执行限流策略，当单位时间结束后，计数器清零，这个过程周而复始，就是计数器法。
• 缺点：不能均衡限流，在一个单位时间的末尾和下一个单位时间的开始，很可能会有两个访问的峰值，导致系统崩溃。
• 改进方式：可以通过减小单位时间来提高精度。

2.漏桶算法

• 原理：假设有一个水桶，水桶有一定的容量，所有请求不论速度都会注入到水桶中，然后水桶以一个恒定的速度向外将请求放出，当水桶满了的时候，新的请求被丢弃。
• 优点：可以平滑请求，削减峰值。
• 缺点：瓶颈会在漏出的速度，可能会拖慢整个系统，且不能有效地利用系统的资源。  

3.令牌桶算法(推荐)

• 原理：有一个令牌桶，单位时间内令牌会以恒定的数量（即令牌的加入速度）加入到令牌桶中，所有请求都需要获取令牌才可正常访问。当令牌桶中没有令牌可取的时候，则拒绝请求。
• 优点：相比漏桶算法，令牌桶算法允许一定的突发流量，但是又不会让突发流量超过我们给定的限制（单位时间窗口内的令牌数）。即限制了我们所说的 QPS(每秒查询率)。

实现

1.依赖

    com.google.guava
    guava
    27.1-jre

2.注解类

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * @author EDZ
 * @Classname RequestLimiter
 * @Description TODO
 * @Date 2020/6/29 17:46
 * @Created zzf
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestLimiter {

    /**
     * 每秒创建令牌个数，默认:10
     */
    double QPS() default 10D;

    /**
     * 获取令牌等待超时时间 默认:500
     */
    long timeout() default 500;

    /**
     * 超时时间单位 默认:毫秒
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;

    /**
     * 无法获取令牌返回提示信息
     */
    String msg() default "服务器繁忙,请稍后重试!";
}

3.定义一个枚举类用于状态返回

/**
 * @Classname ResponseEnum
 * @Description TODO
 * @Date 2020/6/29 17:52
 * @Created zzf
 */
public enum ResponseEnum {

    SUCCESS("200", "000000", "请求成功"),
    FAIL("200", "100000", "请求失败"),
    FAIL_BY_PARAMS("200", "200000", "请求参数异常"),
    FAIL_IN_SERVER("200", "300000", "服务器内部异常"),
    RATE_LIMIT("200", "400000", "限流中");

    public String status;
    public String code;
    public String message;

    ResponseEnum(String s, String s1, String s2) {
        this.status = s;
        this.code = s1;
        this.message = s2;
    }
}

4.自定义拦截器，并在拦截器中实现限流

import com.alibaba.fastjson.JSON;
import com.ils.intelab.common.result.CommonResult;
import com.ils.intelab.openapi.client.enums.ResponseEnum;
import com.ils.intelab.openapi.client.result.OpenApiResultCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

/**
 * 抽象拦截器
 */
public abstract class AbstractInterceptor extends HandlerInterceptorAdapter {
    private Logger logger = LoggerFactory.getLogger(AbstractInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ResponseEnum result;
        try {
            result = preFilter(request, response, handler);
        } catch (Exception e) {
            logger.error("preHandle catch a exception:" + e.getMessage());
            result = ResponseEnum.FAIL;
        }
        if (ResponseEnum.SUCCESS.code.equals(result.code)) {
            return true;
        }
        handlerResponse(result, response);
        return false;
    }


    /**
     * 自定义pre处理
     *
     * @param request
     * @return
     */
    protected abstract ResponseEnum preFilter(HttpServletRequest request, HttpServletResponse response, Object handler);

    /**
     * 错误处理事件
     *
     * @param result
     * @param response
     */
    private void handlerResponse(ResponseEnum result, HttpServletResponse response) {
        CommonResult commonResult = new CommonResult();
        commonResult.setData(null);
        CommonResult