使用springboot整合RateLimiter限流過程

更新時間：2022年06月07日 11:05:17 作者：DY丶老周

這篇文章主要介紹了使用springboot整合RateLimiter限流過程，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

RateLimiter令牌桶原理圖

隨著時間流逝,系統(tǒng)會按恒定1/QPS時間間隔(如果QPS=100,則間隔是10ms)往桶里加入Token(想象和漏洞漏水相反,有個水龍頭在不斷的加水),如果桶已經(jīng)滿了就不再加了.新請求來臨時,會各自拿走一個Token,如果沒有Token可拿了就阻塞或者拒絕服務.
令牌桶的另外一個好處是可以方便的改變速度. 一旦需要提高速率,則按需提高放入桶中的令牌的速率. 一般會定時(比如100毫秒)往桶中增加一定數(shù)量的令牌, 有些變種算法則實時的計算應該增加的令牌的數(shù)量.

令牌桶是一種常用的流量控制技術。令牌桶本身沒有丟棄和優(yōu)先級策略。

原理

1．令牌以一定的速率放入桶中。

2．每個令牌允許源發(fā)送一定數(shù)量的比特。

3．發(fā)送一個包，流量調(diào)節(jié)器就要從桶中刪除與包大小相等的令牌數(shù)。

4．如果沒有足夠的令牌發(fā)送包，這個包就會等待直到有足夠的令牌（在整形器的情況下）或者包被丟棄，也有可能被標記更低的DSCP（在策略者的情況下）。

5．桶有特定的容量，如果桶已經(jīng)滿了，新加入的令牌就會被丟棄。因此，在任何時候，源發(fā)送到網(wǎng)絡上的最大突發(fā)數(shù)據(jù)量與桶的大小成比例。令牌桶允許突發(fā)，但是不能超過限制。

方法摘要

修飾符和類型	方法和描述

double	acquire() 從RateLimiter獲取一個許可，該方法會被阻塞直到獲取到請求
double	acquire(int permits) 從RateLimiter獲取指定許可數(shù)，該方法會被阻塞直到獲取到請求
static RateLimiter	create(double permitsPerSecond) 根據(jù)指定的穩(wěn)定吞吐率創(chuàng)建RateLimiter，這里的吞吐率是指每秒多少許可數(shù)（通常是指QPS，每秒多少查詢）
static RateLimiter	create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) 根據(jù)指定的穩(wěn)定吞吐率和預熱期來創(chuàng)建RateLimiter，這里的吞吐率是指每秒多少許可數(shù)（通常是指QPS，每秒多少個請求量），在這段預熱時間內(nèi)，RateLimiter每秒分配的許可數(shù)會平穩(wěn)地增長直到預熱期結束時達到其最大速率。（只要存在足夠請求數(shù)來使其飽和）
double	getRate() 返回RateLimiter 配置中的穩(wěn)定速率，該速率單位是每秒多少許可數(shù)
void	setRate(double permitsPerSecond) 更新RateLimite的穩(wěn)定速率，參數(shù)permitsPerSecond 由構造RateLimiter的工廠方法提供。
String	toString() 返回對象的字符表現(xiàn)形式
boolean	tryAcquire() 從RateLimiter 獲取許可，如果該許可可以在無延遲下的情況下立即獲取得到的話
boolean	tryAcquire(int permits) 從RateLimiter 獲取許可數(shù)，如果該許可數(shù)可以在無延遲下的情況下立即獲取得到的話
boolean	tryAcquire(int permits, long timeout, TimeUnit unit) 從RateLimiter 獲取指定許可數(shù)如果該許可數(shù)可以在不超過timeout的時間內(nèi)獲取得到的話，或者如果無法在timeout 過期之前獲取得到許可數(shù)的話，那么立即返回false （無需等待）
boolean	tryAcquire(long timeout, TimeUnit unit) 從RateLimiter 獲取許可如果該許可可以在不超過timeout的時間內(nèi)獲取得到的話，或者如果無法在timeout 過期之前獲取得到許可的話，那么立即返回false（無需等待）

開始貼代碼

pom.xml

<!--guava RateLimiter限流-->
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>28.2-jre</version>
</dependency>

自定義接口Limit

package com.zjy.knife4j.inte;
import java.lang.annotation.*;
/**
 * 限流注解
 */
@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Limit {
    // 默認每秒放入桶中的token
    double limitNum() default 20;
    String name() default "";
}

aop切面

package com.zjy.knife4j.aspect;
import com.google.common.util.concurrent.RateLimiter;
import com.zjy.knife4j.inte.Limit;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;
@Aspect
@Component
public class RateLimitAspect {
    /**日志對象*/
    private static final Logger logger = LoggerFactory.getLogger(RateLimitAspect.class);
    private ConcurrentHashMap<String, RateLimiter> RATE_LIMITER  = new ConcurrentHashMap<>();
    private RateLimiter rateLimiter;
    @Pointcut("@annotation(com.zjy.knife4j.inte.Limit)")
    public void serviceLimit() {
    }
    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object obj = null;
        //獲取攔截的方法名
        Signature sig = point.getSignature();
        //獲取攔截的方法名
        MethodSignature msig = (MethodSignature) sig;
        //返回被織入增加處理目標對象
        Object target = point.getTarget();
        //為了獲取注解信息
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        //獲取注解信息
        Limit annotation = currentMethod.getAnnotation(Limit.class);
        double limitNum = annotation.limitNum(); //獲取注解每秒加入桶中的token
        String functionName = msig.getName(); // 注解所在方法名區(qū)分不同的限流策略
        if(RATE_LIMITER.containsKey(functionName)){
            rateLimiter=RATE_LIMITER.get(functionName);
        }else {
            RATE_LIMITER.put(functionName, RateLimiter.create(limitNum));
            rateLimiter=RATE_LIMITER.get(functionName);
        }
        if(rateLimiter.tryAcquire()) {
            logger.info("執(zhí)行成功！??！...做一些業(yè)務處理");
            return point.proceed();
        } else {
            logger.info("請求繁忙...做一些業(yè)務處理");
            return null;
        }
    }
}

RateLimiterController

package com.zjy.knife4j.controller;
import com.zjy.knife4j.inte.Limit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RequestMapping("/ratelimiter")
@RestController
public class RateLimiterController {
    /**
     * 開啟限流
     * @return
     */
    @GetMapping("/open")
    @Limit(limitNum = 1, name = "test1")
    public String openRateLimiter1() {
        System.out.println("【限流執(zhí)行了....編寫業(yè)務....】");
        return "限流執(zhí)行了";
    }
    /**
     * 開啟限流
     * @return
     */
    @GetMapping("/open2")
    @Limit(limitNum = 1, name = "test2")
    public String openRateLimiter2() {
        System.out.println("【限流執(zhí)行了222】");
        return "限流執(zhí)行了222";
    }
    /**
     * 未開啟限流
     * @return
     */
    @GetMapping("/close")
    public String closeRateLimiter() {
        System.out.println("【不限流執(zhí)行了】");
        return "不限流執(zhí)行了";
    }
}