基于Guava库的RateLimter实现注解控制接口速率限流（纯代码）

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
 
/**
 * 限速注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Limiter {
    /**
     * 每秒创建令牌个数，默认:200
     */
    double QPS() default 200;
 
    /**
     * 获取令牌等待超时时间 默认:500
     */
    long timeout() default 500;
 
    /**
     * 超时时间单位 默认:毫秒
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;
 
    /**
     * 限速提示信息
     */
    String msg() default "请稍后再试!";
}

import java.io.PrintWriter;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.util.concurrent.RateLimiter;

import lombok.extern.slf4j.Slf4j;

/**
 * 限速拦截器
 */
@Component
@Slf4j
public class RequestLimitingInterceptor implements HandlerInterceptor {
    private final Map<String, RateLimiter> rateLimiterMap = new ConcurrentHashMap<>();
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //定义返回信息
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", "msg");
        try {
            if (handler instanceof HandlerMethod) {
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                Limiter rateLimit = handlerMethod.getMethodAnnotation(Limiter.class);
                //判断是否有注解
                if (rateLimit != null) {
                    // 获取请求url
                    String url = request.getRequestURI();
                    RateLimiter rateLimiter;
                    // 判断map集合中是否有创建好的令牌桶
                    if (!rateLimiterMap.containsKey(url)) {
                        // 创建令牌桶
                        rateLimiter = RateLimiter.create(rateLimit.QPS());
                        rateLimiterMap.put(url, rateLimiter);
                    }
                    rateLimiter = rateLimiterMap.get(url);
                    // 获取令牌
                    boolean acquire = rateLimiter.tryAcquire(rateLimit.timeout(), rateLimit.timeunit());
                    if (acquire) {
                        //获取令牌成功
                        return true;
                    } else {
                        log.warn("请求被限流,url:{}", request.getServletPath());
                        response(response, toJsonObject(jsonObject));
                        return false;
                    }
                }
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            response(response, toJsonObject(jsonObject));
            return false;
        }
    }
 
    private void response(HttpServletResponse response, JSONObject jo) {
        response.setContentType("application/json; charset=utf-8");
        response.setCharacterEncoding("UTF-8");
        // 语法糖，自动关闭流
        try (PrintWriter out = response.getWriter()) {
            out.append(jo.toJSONString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private JSONObject toJsonObject(Object o) {
        return JSONObject.parseObject(JSON.toJSONString(o));
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {

    /**
     * 请求限流拦截器
     */
    @Autowired
    protected RequestLimitingInterceptor requestLimitingInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 请求限流 根据后面的通配符路径拦截
        registry.addInterceptor(requestLimitingInterceptor).addPathPatterns("/**");
    }
}

@Limiter(QPS = 0.2, timeout = 100000, timeunit = TimeUnit.MILLISECONDS,msg = "玩命加载中,请稍后再试")