【SpringBoot】如何进行限流？封装AOP注解实现吧

墨蓝 2022-09-17 01:57 192阅读 0赞

### **首先说说，为什么现在要Api接口限流呢？** ###

在互联网时代，高并发、大数据量访问已经成为常态，怎样避免系统资源被耗尽，防止并发过高，在资源内存是你硬件瓶颈的时候，该通过一定限制访问来控制系统的资源分配，避免冲击服务器，把服务器突然击垮，击垮了服务器对大家都没好处，因为这样系统在短时间没法恢复，反而会影响整体的性能。

例如，抢购商品的系统，在面对高并发的情况下，就是采用了限流。在流量高峰期间经常会出现类似提示语；"当前排队人数较多，请稍后再试！"

### 关于限流有哪些算法？ ###

限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。

常见的限流算法有三种：

1. 计数器限流

计数器算法是限流算法里最简单也是最容易实现的一种算法。比如我们规定，对于A接口来说，我们1分钟的访问次数不能超过100个。那么我们可以这么做：在一开 始的时候，我们可以设置一个计数器counter，每当一个请求过来的时候，counter就加1，如果counter的值大于100并且该请求与第一个 请求的间隔时间还在1分钟之内，那么说明请求数过多；如果该请求与第一个请求的间隔时间大于1分钟，且counter的值还在限流范围内，那么就重置 counter，具体算法的示意图如下：

![992fa8f8e1164b43b5c96f4d6ab454ef.png][]

2. 漏桶算法

漏桶算法其实很简单，可以粗略的认为就是注水漏水过程，往桶中以一定速率流出水，以任意速率流入水，当水超过桶流量则丢弃，因为桶容量是不变的，保证了整体的速率。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASm9rZXJfWWU_size_12_color_FFFFFF_t_70_g_se_x_16][]

3. 令牌桶算法

令牌桶算法是比较常见的限流算法之一，大概描述如下：  
1）、所有的请求在处理之前都需要拿到一个可用的令牌才会被处理；  
2）、根据限流大小，设置按照一定的速率往桶里添加令牌；  
3）、桶设置最大的放置令牌限制，当桶满时、新添加的令牌就被丢弃或者拒绝；  
4）、请求达到后首先要获取令牌桶中的令牌，拿着令牌才可以进行其他的业务逻辑，处理完业务逻辑之后，将令牌直接删除；  
5）、令牌桶有最低限额，当桶中的令牌达到最低限额的时候，请求处理完之后将不会删除令牌，以此保证足够的限流；

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASm9rZXJfWWU_size_20_color_FFFFFF_t_70_g_se_x_16][]

关于实现

在当今的时代，其实我们不用再写具体的逻辑，我们可以使用封装好插件，例如Google开源工具包Guava提供了限流工具类RateLimiter，该类基于令牌桶算法实现流量限制，使用十分方便，而且十分高效

第一步：引入guava依赖包

pom.xml

<dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>30.1-jre</version>
    </dependency>

加入AOP依赖，这个如果项目已经引入可忽略

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

第二步：定义限流注解

@Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD})
    @Documented
    public @interface Limit {
        /**
         * 资源的key,唯一
         * 作用：不同的接口，不同的流量控制
         */
        String key() default "";
    
        /**
         * 最多的访问限制次数
         */
        double permitsPerSecond () ;
    
        /**
         * 获取令牌最大等待时间
         */
        long timeout();
    
        /**
         * 获取令牌最大等待时间,单位(例:分钟/秒/毫秒) 默认:毫秒
         */
        TimeUnit timeunit() default TimeUnit.MILLISECONDS;
    
        /**
         * 得不到令牌的提示语
         */
        String msg() default "系统繁忙,请稍后再试.";
    }

第三步：实现拦截限流注解的逻辑

@Slf4j
    @Aspect
    @Component
    public class LimitAop {
        /**
         * 不同的接口，不同的流量控制
         * map的key为 Limiter.key
         */
        private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
    
        @Around("@annotation(com.jy.interceptor.limit.Limit)")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            //拿limit的注解
            Limit limit = method.getAnnotation(Limit.class);
            if (limit != null) {
                //key作用：不同的接口，不同的流量控制
                String key=limit.key();
                RateLimiter rateLimiter = null;
                //验证缓存是否有命中key
                if (!limitMap.containsKey(key)) {
                    // 创建令牌桶
                    rateLimiter = RateLimiter.create(limit.permitsPerSecond());
                    limitMap.put(key, rateLimiter);
                    log.info("新建了令牌桶={}，容量={}",key,limit.permitsPerSecond());
                }
                rateLimiter = limitMap.get(key);
                // 拿令牌
                boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
                // 拿不到命令，直接返回异常提示
                if (!acquire) {
                    log.debug("令牌桶={}，获取令牌失败",key);
                    this.responseFail(limit.msg());
                    return null;
                }
            }
            return joinPoint.proceed();
        }
    
        /**
         * 直接向前端抛出异常
         * @param msg 提示信息
         */
        private void responseFail(String msg)  {
            //这里的实现返回，可以根据自己项目返回对应Json或者对象
            HttpServletResponse response=((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
            ResultData<Object> resultData = ResultData.fail(ReturnCode.LIMIT_ERROR.getCode(), msg);
            WebUtils.writeJson(response,resultData);
        }
    }

Ps：其实这里around的逻辑可以根据需要切换不同的算法哦~~

第四步：给需要限流的Controller接口加上注解

@Slf4j
    @RestController
    @RequestMapping("/limit")
    public class LimitController {
        
        @GetMapping("/test2")
        @Limit(key = "limit2", permitsPerSecond = 1, timeout = 500, timeunit = TimeUnit.MILLISECONDS,msg = "当前排队人数较多，请稍后再试！")
        public String limit2() {
            log.info("令牌桶limit2获取令牌成功");
            return "ok";
        }
    
    
        @GetMapping("/test3")
        @Limit(key = "limit3", permitsPerSecond = 2, timeout = 500, timeunit = TimeUnit.MILLISECONDS,msg = "系统繁忙，请稍后再试！")
        public String limit3() {
            log.info("令牌桶limit3获取令牌成功");
            return "ok";
        }
    }

**测试效果**

通过访问测试地址：http://127.0.0.1:8080/limit/test2，反复刷新并观察输出结果：

正常响应时：

{"status":100,"message":"操作成功","data":"ok","timestamp":1632579377104}

触发限流时：

{"status":2001,"message":"系统繁忙，请稍后再试！","data":null,"timestamp":1632579332177}

然后，这个就是我们想要的结果，给一些很重要的api加上限流，有时是很必要的，像有些像处理图片，视频，或者大数据的api

一般在系统上线时我们通过对系统压测可以评估出系统的性能阀值，然后给接口加上合理的限流参数，防止出现大流量请求时直接压垮系统。

至于测试的可以用工具Jmeter，或者Postman都可以，如果懒的可以用代码 线程测试也是可以的

哈哈，最后谢谢大家的观看！下次有好的代码提高性能的我还是不留余力给大家分享的！！！

[992fa8f8e1164b43b5c96f4d6ab454ef.png]: /images/20220828/d7e05204aa1543d294efa90d0f4f7f98.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASm9rZXJfWWU_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/0719f076bc4a4074aa028b75fb5241a9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASm9rZXJfWWU_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/31b2161f832947e4a19f68b6c495eb0f.png