SpringBoot 如何進行限流

如何優雅的進行限流（基于aop）。

首先就讓我們來看看為什麼需要對接口進行限流？

為什麼要進行限流？

因為網際網路系統通常都要面對大并發大流量的請求，在突發情況下（最常見的場景就是秒殺、搶購），瞬時大流量會直接将系統打垮，無法對外提供服務。那為了防止出現這種情況最常見的解決方案之一就是限流，當請求達到一定的并發數或速率，就進行等待、排隊、降級、拒絕服務等。

例如，12306購票系統，在面對高并發的情況下，就是采用了限流。 在流量高峰期間經常會出現提示語；“目前排隊人數較多，請稍後再試！”

什麼是限流？有哪些限流算法？

限流是對某一時間視窗内的請求數進行限制，保持系統的可用性和穩定性，防止因流量暴增而導緻的系統運作緩慢或當機。

常見的限流算法有三種：

1. 計數器限流

計數器限流算法是最為簡單粗暴的解決方案，主要用來限制總并發數，比如資料庫連接配接池大小、線程池大小、接口通路并發數等都是使用計數器算法。

如：使用 aomicinteger 來進行統計目前正在并發執行的次數，如果超過域值就直接拒絕請求，提示系統繁忙。

2. 漏桶算法

漏桶算法思路很簡單，我們把水比作是請求，漏桶比作是系統處理能力極限，水先進入到漏桶裡，漏桶裡的水按一定速率流出，當流出的速率小于流入的速率時，由于漏桶容量有限，後續進入的水直接溢出（拒絕請求），以此實作限流。

3. 令牌桶算法

令牌桶算法的原理也比較簡單，我們可以了解成醫院的挂号看病，隻有拿到号以後才可以進行診病。

系統會維護一個令牌（token）桶，以一個恒定的速度往桶裡放入令牌（token），這時如果有請求進來想要被處理，則需要先從桶裡擷取一個令牌（token），當桶裡沒有令牌（token）可取時，則該請求将被拒絕服務。令牌桶算法通過控制桶的容量、發放令牌的速率，來達到對請求的限制。

基于guava工具類實作限流

google開源工具包guava提供了限流工具類ratelimiter，該類基于令牌桶算法實作流量限制，使用十分友善，而且十分高效，實作步驟如下：

第一步：引入guava依賴包

<dependency>

    <groupid>com.google.guava</groupid>

    <artifactid>guava</artifactid>

    <version>30.1-jre</version>

</dependency>

第二步：給接口加上限流邏輯

@slf4j

@restcontroller

@requestmapping("/limit")

public class limitcontroller {

    /**

     * 限流政策 ： 1秒鐘2個請求

     */

    private final ratelimiter limiter = ratelimiter.create(2.0);

    private datetimeformatter dtf = datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss");

    @getmapping("/test1")

    public string testlimiter() {

        //500毫秒内，沒拿到令牌，就直接進入服務降級

        boolean tryacquire = limiter.tryacquire(500, timeunit.milliseconds);

        if (!tryacquire) {

            log.warn("進入服務降級，時間{}", localdatetime.now().format(dtf));

            return "目前排隊人數較多，請稍後再試！";

        }

        log.info("擷取令牌成功，時間{}", localdatetime.now().format(dtf));

        return "請求成功";

    }

}

以上用到了ratelimiter的2個核心方法：create()、tryacquire()，以下為詳細說明

acquire() 擷取一個令牌, 改方法會阻塞直到擷取到這一個令牌, 傳回值為擷取到這個令牌花費的時間

acquire(int permits) 擷取指定數量的令牌, 該方法也會阻塞, 傳回值為擷取到這 n 個令牌花費的時間

tryacquire() 判斷時候能擷取到令牌, 如果不能擷取立即傳回 false

tryacquire(int permits) 擷取指定數量的令牌, 如果不能擷取立即傳回 false

tryacquire(long timeout, timeunit unit) 判斷能否在指定時間内擷取到令牌, 如果不能擷取立即傳回 false

tryacquire(int permits, long timeout, timeunit unit) 同上

第三步：體驗效果

通過通路測試位址： http://127.0.0.1:8080/limit/test1，反複重新整理并觀察後端日志

warn  limitcontroller:35 - 進入服務降級，時間2021-09-25 21:39:37

info  limitcontroller:39 - 擷取令牌成功，時間2021-09-25 21:39:37

warn  limitcontroller:35 - 進入服務降級，時間2021-09-25 21:39:38

info  limitcontroller:39 - 擷取令牌成功，時間2021-09-25 21:39:38

從以上日志可以看出，1秒鐘内隻有2次成功，其他都失敗降級了，說明我們已經成功給接口加上了限流功能。

當然了，我們在實際開發中并不能直接這樣用。至于原因嘛，你想呀，你每個接口都需要手動給其加上tryacquire()，業務代碼和限流代碼混在一起，而且明顯違背了dry原則，代碼備援，重複勞動。代碼評審時肯定會被老鳥們給嘲笑一番，啥破玩意兒！

是以，我們這裡需要想辦法将其優化 - 借助自定義注解+aop實作接口限流。

基于aop實作接口限流

基于aop的實作方式也非常簡單，實作過程如下：

第一步：加入aop依賴

  <groupid>org.springframework.boot</groupid>

  <artifactid>spring-boot-starter-aop</artifactid>

第二步：自定義限流注解

@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 "系統繁忙,請稍後再試.";

第三步：使用aop切面攔截限流注解

@aspect

@component

public class limitaop {

     * 不同的接口，不同的流量控制

     * map的key為 limiter.key

    private final map<string, ratelimiter> limitmap = maps.newconcurrentmap();

    @around("@annotation(com.jianzh5.blog.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)  {

        httpservletresponse response=((servletrequestattributes) requestcontextholder.getrequestattributes()).getresponse();

        resultdata<object> resultdata = resultdata.fail(returncode.limit_error.getcode(), msg);

        webutils.writejson(response,resultdata);

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

    @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擷取令牌成功");

第五步：體驗效果

通過通路測試位址： http://127.0.0.1:8080/limit/test2，反複重新整理并觀察輸出結果：

正常響應時：

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

1

觸發限流時：

{"status":2001,"message":"系統繁忙，請稍後再試！","data":null,"timestamp":1632579332177}

通過觀察得之，基于自定義注解同樣實作了接口限流的效果。

小結

一般在系統上線時我們通過對系統壓測可以評估出系統的性能閥值，然後給接口加上合理的限流參數，防止出現大流量請求時直接壓垮系統。今天我們介紹了幾種常見的限流算法（重點關注令牌桶算法），基于guava工具類實作了接口限流并利用aop完成了對限流代碼的優化。

在完成優化後業務代碼和限流代碼解耦，開發人員隻要一個注解，不用關心限流的實作邏輯，而且減少了代碼備援大大提高了代碼可讀性