SpringBoot基于RateLimiter+AOP动态的为不同接口限流

公司需要对接第三方接口,每个接口都有频率限制,只好做下精准的限流,精准到方法,如果是服务的话Hystrix应该可以的,废话不多说,看了一篇不错的文章,亲测可行,记录一下.
1.首先接口限流算法:

  1.计数器方式(传统计数器缺点:临界问题 可能违背定义固定速率原则)

SpringBoot基于RateLimiter+AOP动态的为不同接口限流_第1张图片
2.令牌桶方式
SpringBoot基于RateLimiter+AOP动态的为不同接口限流_第2张图片

  3.漏桶方式

SpringBoot基于RateLimiter+AOP动态的为不同接口限流_第3张图片
4.应用层限流(Nginx)
2.限流实现:

2.1. RateLimiter是guava提供的基于令牌桶算法的实现类,可以非常简单的完成限流特技,并且根据系统的实际情况来调整生成token的速率。

2.2.导入相关依赖包


    org.springframework.boot
    spring-boot-starter-web

 

    org.aspectj
    aspectjweaver

 

    org.springframework.boot
    spring-boot-starter-test
    test

 

    com.google.guava
    guava
    20.0

2.3.代码实现不多说每一步都有注解

2.3.1 定义注解

    @Inherited
    @Documented
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RateLimit {
        double limitNum() default 20;  //默认每秒放入桶中的token
    }

2.3.2 封装定义返回结果

    public class MyResult {
        private Integer status;
        private String msg;
        private List data;
 
        public MyResult(Integer status, String msg, List data) {
            this.status = status;
            this.msg = msg;
            this.data = data;
        }
 
        public static MyResult OK(String msg, List data) {
            return new MyResult(200, msg, data);
        }
 
        public static MyResult Error(Integer status, String msg) {
            return new MyResult(status, msg, null);
        }
 
  

2.3.3 aop实现

    @Component
    @Scope
    @Aspect
    public class RateLimitAspect {
        private Logger log = LoggerFactory.getLogger(this.getClass());
        //用来存放不同接口的RateLimiter(key为接口名称,value为RateLimiter)
        private ConcurrentHashMap map = new ConcurrentHashMap<>();
     
        private static ObjectMapper objectMapper = new ObjectMapper();
     
        private RateLimiter rateLimiter;
     
        @Autowired
        private HttpServletResponse response;
     
        @Pointcut("@annotation(com.icat.retalimitaop.annotation.RateLimit)")
        public void serviceLimit() {
        }
     
        @Around("serviceLimit()")
        public Object around(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
            Object obj = null;
            //获取拦截的方法名
            Signature sig = joinPoint.getSignature();
            //获取拦截的方法名
            MethodSignature msig = (MethodSignature) sig;
            //返回被织入增加处理目标对象
            Object target = joinPoint.getTarget();
            //为了获取注解信息
            Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
            //获取注解信息
            RateLimit annotation = currentMethod.getAnnotation(RateLimit.class);
            double limitNum = annotation.limitNum(); //获取注解每秒加入桶中的token
            String functionName = msig.getName(); // 注解所在方法名区分不同的限流策略
     
            //获取rateLimiter
             if(map.containsKey(functionName)){
                 rateLimiter = map.get(functionName);
             }else {
                 map.put(functionName, RateLimiter.create(limitNum));
                 rateLimiter = map.get(functionName);
             }
     
            try {
                if (rateLimiter.tryAcquire()) {
                    //执行方法
                    obj = joinPoint.proceed();
                } else {
                    //拒绝了请求(服务降级)
                    String result = objectMapper.writeValueAsString(MyResult.Error(500, "系统繁忙!"));
                    log.info("拒绝了请求:" + result);
                    outErrorResult(result);
                }
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
            return obj;
        }
        //将结果返回
        public void outErrorResult(String result) {
            response.setContentType("application/json;charset=UTF-8");
            try (ServletOutputStream outputStream = response.getOutputStream()) {
                outputStream.write(result.getBytes("utf-8"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
     
        static {
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        }
     
    }

3.测试限流

   2个接口设定没秒限流5个和美妙限流10个 
    @RateLimit(limitNum = 5.0)
    public MyResult getResults() {
        log.info("调用了方法getResults");
        return MyResult.OK("调用了方法", null);
    }
 
    @RateLimit(limitNum = 10.0)
    public MyResult getResultTwo() {
        log.info("调用了方法getResultTwo");
        return MyResult.OK("调用了方法getResultTwo", null);
   }

使用postman测试getResults接口 20个并发(设定每秒只能处理5个请求)
SpringBoot基于RateLimiter+AOP动态的为不同接口限流_第4张图片
使用postman测试getResultTwo接口 20个并发(设定每秒只能处理10个请求)
SpringBoot基于RateLimiter+AOP动态的为不同接口限流_第5张图片转自:https://blog.csdn.net/qq_39816039/article/details/83988517

你可能感兴趣的:(Java,springboot,RateLimiter,Aop,接口限流,精准)