在项目中使用（guava的RateLimiter）基于自定义注解方式实现 实战限流

1、单体项目可以使用这种方式实现限流，而分布式和集群项目是 基于基于Redis+Lua的分布式限流

常用的限流算法有漏桶算法和令牌桶算法，guava的RateLimiter使用的是令牌桶算法，也就是以固定的频率向桶中放入令牌，例如一秒钟10枚令牌，实际业务在每次响应请求之前都从桶中获取令牌，只有取到令牌的请求才会被成功响应，获取的方式有两种：阻塞等待令牌或者取不到立即返回失败，下图来自网上：

本次实战，我们用的是guava的RateLimiter，场景是spring mvc在处理请求时候，从桶中申请令牌，申请到了就成功响应，申请不到时直接返回失败；

这是一个maven工程，所以首先我们在pom中把guava的依赖添加进来：

<!--限流引入的jar-->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.1-jre</version>
</dependency>

1、自定义注解限流类如下：

import java.lang.annotation.*;

@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CustomRateLimiter {

    //往令牌桶放入令牌的速率
    double rate();
    //获取令牌的超时时间
    long timeOut() default 0;
}

2、自定义切面类 RateLimiterAspect类 ，修改扫描自己controller类

import com.google.common.util.concurrent.RateLimiter;
import com.imooc.annotation.CustomRateLimiter;
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.aspectj.lang.reflect.MethodSignature;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

@Aspect
@Component
public class RateLimiterAspect {
    @Autowired
    private HttpServletResponse response;

    //创建了一个令牌桶限流算法的限流器, 方便测试创建每秒创建2桶
    private RateLimiter rateLimiter = RateLimiter.create(2);

    public final static Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);

    @Pointcut("execution( public * com.zz.controller.*.*(..))")
    public void pointcut(){

    }
    @Around("pointcut()")
    public Object process(ProceedingJoinPoint proceedingJoinPoint) throws  Throwable {
        MethodSignature  signature = (MethodSignature)proceedingJoinPoint.getSignature();
        //使用Java 反射技术获取方法上是否有@CustomRateLimiter 注解类
        CustomRateLimiter geelyRateLimiter = signature.getMethod().getDeclaredAnnotation(CustomRateLimiter.class);
        if(geelyRateLimiter == null){
            //正常执行方法,执行正常业务逻辑
            return proceedingJoinPoint.proceed();
        }
        //获取注解上的参数，获取配置的速率
        double rate = geelyRateLimiter.rate();
        //获取注解上的参数，获取等待令牌等待时间
        long timeOut = geelyRateLimiter.timeOut();
        // 设置限流速率
        rateLimiter.setRate(rate);
        boolean tryAcquire = rateLimiter.tryAcquire(500, TimeUnit.MILLISECONDS);
        if(!tryAcquire){
            //服务降级
            fullback();
            return null;

        }
        // 获取到令牌，直接放行
        return proceedingJoinPoint.proceed();
    }



    private  void  fullback(){
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        PrintWriter writer = null;
        try {
            writer= response.getWriter();
            JSONObject o = new JSONObject();
            // 自定义返回默认值 ， 状态码可以根据自己系统设置  status ：我这边默认是500错误
            o.put("status",500);
            o.put("msg","请求太频繁，请稍后重试！");
            o.put("data",null);
            writer.printf(o.toString()
            );

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(writer != null){
                writer.close();
            }
        }
    }
}

3、在需要限流的类添加注解： test 改接口是没有用切面方式，有代码入侵，基于注解的test1是没有代码入侵。

import java.util.concurrent.TimeUnit;
@RestController
@Api(value = "限流", tags = {"限流测试接口"})
@RequestMapping("limiter")
public class LimiterController {

    //表示桶容量为5，且每秒新增5个令牌 。1秒等于1000毫秒 表示：200毫秒放一个令牌
    RateLimiter limiter = RateLimiter.create(2);

    @ApiOperation(value = "限流测试接口",notes = "限流测试接口", httpMethod = "GET")
    @GetMapping("/test")
    public CustomJSONResult test(){
        //1.限流处理，客户端请求从桶中获取令牌，如果在500毫秒内没有获取到令牌，则直接走服务降级处理
        boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
        if(!tryAcquire){
            return CustomJSONResult.errorMsg("请求太频繁，请稍后重试！");
        }
        return IMOOCJSONResult.ok();
    }


    @ApiOperation(value = "自定义限流注解测试接口",notes = "自定义限流注解测试接口", httpMethod = "GET")
    @CustomRateLimiter(rate = 1.0,timeOut = 500)
    @GetMapping("/test2")
    public CustomJSONResult test2(){
        System.out.println("正常执行业务逻辑");
        return CustomJSONResult.ok();
    }

}

4、使用 jmeter测试接口；这样就达到限流。