Guava包RateLimiter實現接口API限流

常用的限流算法有漏桶算法和令牌桶算法，guava的RateLimiter使用的是令牌桶算法，也就是以固定的頻率向桶中放入令牌，例如一秒鐘10枚令牌，實際業務在每次響應請求之前都從桶中獲取令牌，只有取到令牌的請求才會被成功響應，獲取的方式有兩種：阻塞等待令牌或者取不到立即返回失敗，下圖來自網上：

Guava提供的RateLimiter可以限制物理或邏輯資源的被訪問速率，有點與java併發包下的Samephore類似，但是又不相同，RateLimiter控制的是速率，Samephore控制的是併發量。RateLimiter的原理類似於令牌桶，它主要由許可發出的速率來定義，如果沒有額外的配置，許可證將按每秒許可證規定的固定速度分配，許可將被平滑地分發，若請求超過permitsPerSecond則RateLimiter按照每秒 1/permitsPerSecond 的速率釋放許可。

RateLimiter方法摘要

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

案例

項目集成：

<dependency>
   <groupId>com.google.guava</groupId>
   <artifactId>guava</artifactId>
   <version>23.0</version>
</dependency>

案例：

public class Test {
    public static void main(String[] args) {
        String start = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        RateLimiter limiter = RateLimiter.create(1.0); // 這裏的1表示每秒允許處理的量爲1個
        for (int i = 1; i <= 10; i++) {
            limiter.acquire();// 請求RateLimiter, 超過permits會被阻塞
            System.out.println("call execute.." + i);
        }
        String end = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("start time:" + start);
        System.out.println("end time:" + end);
    }
}

執行結果：

總結：

​ 可以看到，我假定了每秒處理請求的速率爲1個，現在我有10個任務要處理，那麼RateLimiter就很好的實現了控制速率，總共10個任務，需要9次獲取許可，所以最後10個任務的消耗時間爲9s左右

項目實例一

@Service
public class GuavaRateLimiterService {
    /**
     * 每秒控制5個許可
     */
    RateLimiter rateLimiter = RateLimiter.create(5.0);
    /**
     * @Description獲取令牌
     * @Param
     * @Return
     * @Exception
     * @Author  yaoyonghao
     * @Date   2020/6/1 10:54
     */
    public boolean tryAcquire(){
        return   rateLimiter.tryAcquire();
    }
}

@RestController
public class TestController extends BaseController {
    @Autowired
    private GuavaRateLimiterService rateLimiterService;
    @ResponseBody
    @RequestMapping("/ratelimiter")
    public String testRateLimiter() {
        if (rateLimiterService.tryAcquire()) {
            return returnMsgResult(ErrorConstantsCode.SUCCESS, "成功獲取許可");
        } else {
            return returnMsgResult(ErrorConstantsCode.ERROR, "未獲取到許可");
        }
    }
}

通過postman併發測試結果發現：可以發現，10個併發訪問總是隻有6個能獲取到許可，結論就是能獲取到RateLimiter.create(n)中n+1個許可

項目實例二

如果像上邊使用不夠靈活，如果換成自定義註解+切面 的方式實現的話，會優雅的多

自定義註解

@Inherited
@Documented
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAspect {
}

自定義切面

@Component
@Scope
@Aspect
public class RateLimitAop { 
    @Autowired
    private HttpServletResponse response; 
    private RateLimiter rateLimiter = RateLimiter.create(5.0); //比如說，我這裏設置"併發數"爲5
 
    @Pointcut("@annotation(com.simons.cn.springbootdemo.aspect.RateLimitAspect)")
    public void serviceLimit() { 
    }
 
    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Boolean flag = rateLimiter.tryAcquire();
        Object obj = null;
        try {
            if (flag) {
                obj = joinPoint.proceed();
            }else{
                String result = JSONObject.fromObject(ResultUtil.success1(100, "failure")).toString();
                output(response, result);
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("flag=" + flag + ",obj=" + obj);
        return obj;
    }
    
    public void output(HttpServletResponse response, String msg) throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        ServletOutputStream outputStream = null;
        try {
            outputStream = response.getOutputStream();
            outputStream.write(msg.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            outputStream.flush();
            outputStream.close();
        }
    }
}

@RestController
public class TestController extends BaseController {
    @Autowired
    private GuavaRateLimiterService rateLimiterService;
    
    @RateLimitAspect         //可以非常方便的通過這個註解來實現限流
    @ResponseBody
    @RequestMapping("/ratelimiter")
    public String testRateLimiter() {
        if (rateLimiterService.tryAcquire()) {
            return returnMsgResult(ErrorConstantsCode.SUCCESS, "成功獲取許可");
        } else {
            return returnMsgResult(ErrorConstantsCode.ERROR, "未獲取到許可");
        }
    }
}

這是我得微信公衆號：程序猿微刊 更多文章請關注微信公衆號