导入依赖

  1. <dependency>
  2.   <groupId>com.google.guava</groupId>
  3.   <artifactId>guava</artifactId>
  4.   <version>30.1.1-jre</version>
  5. </dependency>

自定义注解

  1. import java.lang.annotation.*;
  3. //表示该注解被用于方法上
  4. @Target(ElementType.METHOD)
  5. //表示该注解保留到运行时
  6. @Retention(RetentionPolicy.RUNTIME)
  7. @Documented
  8. public @interface RateLimit {
  9.     /**
  10.     * 该注解实际作用，限流
  11.     * rate 代表每秒钟多少请求
  12.     *
  13.     * @return
  14.     */
  15.     int rate() default 100;
  17.     /**
  18.     * 平滑突发限流（SmoothBursty）和平滑预热限流（SmoothWarmingUp）
  19.     * 平滑突发限流，允许突发流量，后面请求速率控制会趋于平稳
  20.     * 平滑预热限流，开始先于小于最大速率执行，慢慢趋于平稳，接近最大速率
  21.     *
  22.     * @return
  23.     */
  24.     String mode() default RateLimitMode.SMOOTH_BURSTY;
  25. }

自定义注解的切面处理

  2. import com.google.common.util.concurrent.RateLimiter;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.Signature;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.aspectj.lang.reflect.MethodSignature;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  13. import org.springframework.core.annotation.Order;
  14. import org.springframework.stereotype.Component;
  16. import java.util.Objects;
  17. import java.util.concurrent.ConcurrentHashMap;
  18. import java.util.concurrent.TimeUnit;
  20. @Aspect
  21. @Component
  22. @Order(100)
  23. public class RateLimitAspect {
  24.     /**
  25.      * Guava RateLimiter提供的令牌桶算法可用于平滑突发限流（SmoothBursty）和平滑预热限流（SmoothWarmingUp）实现。
  26.      * 设计思路----------------------------
  27.      * 进入切面后，先进入环绕通知，环绕通知里取出注解限定的速度，并以该速度生产令牌放入桶中，(令牌生产速度为 每秒多少个)，在ConcurrentHashMap中以类名+方法名作为key,以RateLimit作为value
  28.      * * before执行时先去桶中获取令牌，获取不到阻塞一段时间。
  29.      */
  30.     private static Logger LOGGER = LoggerFactory.getLogger(RateLimitAspect.class);
  31.     public static final int PERMITS_PER_SECOND = 100;
  32.     private static ConcurrentHashMap<String, RateLimiter> RateLimiterMap = new ConcurrentHashMap<>();
  34.     /**
  35.      * 切入点
  36.      */
  37.     @Pointcut("@annotation(com.example.aop.RateLimit)")
  38.     public void rateLimitCutPoint() {
  39.         LOGGER.info("编入切入点");
  40.     }
  42.     @Before("rateLimitCutPoint()")
  43.     public void rateLimitBefore(JoinPoint joinPoint) {
  44.         String methodName = joinPoint.getTarget().getClass().getName() + "." + joinPoint.getSignature().getName();
  45.         RateLimiter rateLimiter = RateLimiterMap.getOrDefault(methodName, RateLimiter.create(PERMITS_PER_SECOND));
  46.         //获取令牌并计算等待时间 此处可以根据waitTime超过阈值就抛出异常（配合全局异常捕获封装指定返回值，提示接口已经限流了）
  47.         double waitTime = rateLimiter.acquire();
  48.         LOGGER.info("acquire spend {} seconds", waitTime);
  49.     }
  51.     /**
  52.      * 环绕通知必须有返回值, 返回值即为目标方法的返回值
  53.      *
  54.      * @param proceedingJoinPoint
  55.      * @throws Throwable
  56.      */
  57.     @Around("rateLimitCutPoint()")
  58.     public Object rateLimitAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  59.         try {
  60.             Signature signature = proceedingJoinPoint.getSignature();
  61.             //返回进行方法的全名称
  62.             String methodName = proceedingJoinPoint.getTarget().getClass().getName() + "." + signature.getName();
  63.             RateLimit rateLimitAnnotation = ((MethodSignature) signature).getMethod().getDeclaredAnnotation(RateLimit.class);
  64.             //注解上的速率
  65.             int rate = rateLimitAnnotation.rate();
  66.             String mode = rateLimitAnnotation.mode();
  67.             putRate(methodName, rate, mode);
  68.             LOGGER.info("限流方法名{},执行速率{}", methodName, RateLimiterMap.get(methodName).getRate());
  69.         } catch (Exception e) {
  70.             LOGGER.error("限流切面出现异常,异常提示{}", e.getMessage());
  71.         }
  72.         return proceedingJoinPoint.proceed();
  73.     }
  75.     private void putRate(String methodName, int rate, String mode) {
  76.         if (Objects.isNull(RateLimiterMap.get(methodName))) {
  77.             if (mode.equals(RateLimitMode.SMOOTH_BURSTY)) {
  78.                 //SmoothBursty模式下,未使用RateLimit最多保存1秒的令牌,即maxBurstSeconds为1秒
  79.                 RateLimiterMap.putIfAbsent(methodName, RateLimiter.create(rate));
  80.             } else {
  81.                 //SmoothWarmingUp模式
  82.                 // warmupPeriod表示从冷启动速率过渡到平均速率所需要的时间间隔,设置为1分钟
  83.                 RateLimiterMap.putIfAbsent(methodName, RateLimiter.create(rate, 1, TimeUnit.MINUTES));
  84.             }
  85.         }
  86.     }
  87. }

使用到的常量

  2. public class RateLimitMode {
  3.     /**
  4.      * 平滑突发限流（SmoothBursty）和平滑预热限流（SmoothWarmingUp）
  5.      * 平滑突发限流，允许突发流量，后面请求速率控制会趋于平稳
  6.      * 平滑预热限流，开始先于小于最大速率执行，慢慢趋于平稳，接近最大速率
  7.      *
  8.      * @return
  9.      */
  10.     public static final String SMOOTH_BURSTY = "smooth-bursty";
  11.     public static final String SMOOTH_WARMING_UP = "smooth-warming-up";
  13. }

测试接口

  1.     @GetMapping("limit")
  2.     @RateLimit(rate = 50)
  3.     public String test2() {
  4.         return "访问成功";
  5.     }

Jmeter测试结果

  1. 当 @RateLimit(rate = 50)，接口吞吐量(throughput)=47
  2. 当 @RateLimit(rate = 10)，接口吞吐量(throughput)=9.7
  3. 当 @RateLimit(rate = 5)，接口吞吐量(throughput)=5

限流成功