Guava RateLimiter 實作 API 限流，這才是正确的姿勢！

Guava提供的RateLimiter可以限制實體或邏輯資源的被通路速率，咋一聽有點像java并發包下的Samephore，但是又不相同，RateLimiter控制的是速率，Samephore控制的是并發量。

RateLimiter的原理類似于令牌桶，它主要由許可發出的速率來定義，如果沒有額外的配置，許可證将按每秒許可證規定的固定速度配置設定，許可将被平滑地分發，若請求超過permitsPerSecond則RateLimiter按照每秒 1/permitsPerSecond 的速率釋放許可。

<dependency>
   <groupId>com.google.guava</groupId>
   <artifactId>guava</artifactId>
   <version>23.0</version>
</dependency>
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);

    /**
     * 擷取令牌
     *
     * @return
     */
    public boolean tryAcquire() {
        return rateLimiter.tryAcquire();
    }

}
  @Autowired
    private GuavaRateLimiterService rateLimiterService;

    @ResponseBody
    @RequestMapping("/ratelimiter")
    public Result testRateLimiter(){
        if(rateLimiterService.tryAcquire()){
            return ResultUtil.success1(1001,"成功擷取許可");
        }
        return ResultUtil.success1(1002,"未擷取到許可");
    }      

jmeter起10個線程并發通路接口，測試結果如下：

可以發現，10個并發通路總是隻有6個能擷取到許可，結論就是能擷取到RateLimiter.create(n)中n+1個許可，總體來看Guava的RateLimiter是比較優雅的。本文就是簡單的提了下RateLimiter的使用。

翻閱發現使用上述方式使用RateLimiter的方式不夠優雅，盡管我們可以把RateLimiter的邏輯包在service裡面，controller直接調用即可，但是如果我們換成：自定義注解+切面 的方式實作的話，會優雅的多，詳細見下面代碼：

自定義注解類

import java.lang.annotation.*;

/**
 * 自定義注解可以不包含屬性，成為一個辨別注解
 */
@Inherited
@Documented
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAspect {

}      

自定義切面類

import com.google.common.util.concurrent.RateLimiter;
import com.simons.cn.springbootdemo.util.ResultUtil;
import net.sf.json.JSONObject;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@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();
        }
    }
}      

推薦一個 Spring Boot 基礎教程及實戰示例：

https://www.javastack.cn/categories/Spring-Boot/

測試controller類

import com.simons.cn.springbootdemo.aspect.RateLimitAspect;
import com.simons.cn.springbootdemo.util.ResultUtil;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 類描述：RateLimit限流測試（基于 注解+切面 方式）
 * 建立人：simonsfan
 */
@Controller
public class TestController {

    @ResponseBody
    @RateLimitAspect         //可以非常友善的通過這個注解來實作限流
    @RequestMapping("/test")
    public String test(){
        return ResultUtil.success1(1001, "success").toString();
    }      

這樣通過自定義注解@RateLimiterAspect來動态的加到需要限流的接口上，個人認為是比較優雅的實作吧。

壓測結果：

可以看到，10個線程中無論壓測多少次，并發數總是限制在6，也就實作了限流。