自定义封装限流算法

定义注解：
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExtRateLimiter {

    // 以每秒为单位固定的速率值往令牌桶中添加令牌
    double permitsPerSecond();

    // 在规定的毫秒数中,如果没有获取到令牌的话，则直接走服务降级处理
    long timeout();
}
定义AOP：
@Aspect
@Component
public class RateLimiterAop {
    private Map<String, RateLimiter> rateHashMap = new ConcurrentHashMap<>();

    // 定义切入点 拦截com.jarye.api
    @Pointcut("execution(public * com.jarye.api.*.*(..))")

    public void rlAop() {
    }

    // 使用AOP环绕通知判断拦截所有springmvc 请求，判断请求方法上是否存在ExtRateLimiter注解
    @Around("rlAop()")
    public Object doBefore(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 1.如果请求方法上存在@ExtRateLimiter注解的话
        Method sinatureMethod = getSinatureMethod(proceedingJoinPoint);
        if (sinatureMethod == null) {
            // 直接报错
            return null;
        }
        // 2.使用java的反射机制获取拦截方法上自定义注解的参数
        ExtRateLimiter extRateLimiter = sinatureMethod.getDeclaredAnnotation(ExtRateLimiter.class);
        if (extRateLimiter == null) {
            // 直接进入实际请求方法中
            return proceedingJoinPoint.proceed();
        }
        double permitsPerSecond = extRateLimiter.permitsPerSecond();
        long timeout = extRateLimiter.timeout();
        // 3.调用原生的RateLimiter创建令牌 保证每个请求对应都是单例的RateLimiter
        // /index---RateLimiter /order --RateLimiter 使用hashMap key为 请求的url地址##
        // 相同的请求在同一个桶
        String requestURI = getRequestURI();
        RateLimiter rateLimiter = null;
        if (rateHashMap.containsKey(requestURI)) {
            // 如果在hashMap URL 能检测到RateLimiter
            rateLimiter = rateHashMap.get(requestURI);
        } else {
            // 如果在hashMap URL 没有检测到RateLimiter 添加新的RateLimiter
            rateLimiter = RateLimiter.create(permitsPerSecond);
            rateHashMap.put(requestURI, rateLimiter);
        }
        // 4.获取令牌桶中的令牌，如果没有有效期获取到令牌的话，则直接调用本地服务降级方法，不会进入到实际请求方法中。
        boolean tryAcquire = rateLimiter.tryAcquire(timeout, TimeUnit.MILLISECONDS);
        if (!tryAcquire) {
            // 服务降级
            fallback();
            return null;
        }
        // 5.获取令牌桶中的令牌，如果能在有效期获取令牌到令的话，则直接进入到实际请求方法中。
        // 直接进入实际请求方法中
        return proceedingJoinPoint.proceed();
    }

    private void fallback() throws IOException {
        System.out.println("服务降级别抢了， 在抢也是一直等待的， 还是放弃吧！！！");
        // 在AOP编程中获取响应
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = attributes.getResponse();
        response.setHeader("Content-type", "text/html;charset=UTF-8");
        PrintWriter writer = response.getWriter();
        try {
            writer.println("别抢了， 在抢也是一直等待的， 还是放弃吧！！！");
        } catch (Exception e) {

        } finally {
            writer.close();

        }

    }

    private String getRequestURI() {
        return getRequest().getRequestURI();
    }

    private HttpServletRequest getRequest() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return attributes.getRequest();
    }

    // 获取到AOP拦截的方法
    private Method getSinatureMethod(ProceedingJoinPoint proceedingJoinPoint) {
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        // 获取到AOP拦截的方法
        Method method = signature.getMethod();
        return method;
    }

}

使用：
@RequestMapping("/myOrder")
@ExtRateLimiter(value = 10.0, timeOut = 500)
public String myOrder() throws InterruptedException {
        System.out.println("myOrder");
        return "SUCCESS";
}