SpringBoot基于RateLimiter+AOP动态的为不

一 限流实现：

1. RateLimiter是guava提供的基于令牌桶算法的实现类，可以非常简单的完成限流特技，并且根据系统的实际情况来调整生成token的速率。
   2.导入相关依赖包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

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

3.代码实现不多说每一步都有注解

3.1 定义注解

@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    double limitNum() default 20;  //默认每秒放入桶中的token
}
2.3.2 封装定义返回结果

public class MyResult {
    private Integer status;
    private String msg;
    private List<Object> data;

    public MyResult(Integer status, String msg, List<Object> data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public static MyResult OK(String msg, List<Object> data) {
        return new MyResult(200, msg, data);
    }

    public static MyResult Error(Integer status, String msg) {
        return new MyResult(status, msg, null);
    }

3.3 aop实现

@Component
@Scope
@Aspect
public class RateLimitAspect {
private Logger log = LoggerFactory.getLogger(this.getClass());
//用来存放不同接口的RateLimiter(key为接口名称，value为RateLimiter)
private ConcurrentHashMap<String, RateLimiter> map = new ConcurrentHashMap<>();

private static ObjectMapper objectMapper = new ObjectMapper();

private RateLimiter rateLimiter;

@Autowired
private HttpServletResponse response;

@Pointcut("@annotation(com.icat.retalimitaop.annotation.RateLimit)")
public void serviceLimit() {
}

@Around("serviceLimit()")
public Object around(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
    Object obj = null;
    //获取拦截的方法名
    Signature sig = joinPoint.getSignature();
    //获取拦截的方法名
    MethodSignature msig = (MethodSignature) sig;
    //返回被织入增加处理目标对象
    Object target = joinPoint.getTarget();
    //为了获取注解信息
    Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
    //获取注解信息
    RateLimit annotation = currentMethod.getAnnotation(RateLimit.class);
    double limitNum = annotation.limitNum(); //获取注解每秒加入桶中的token
    String functionName = msig.getName(); // 注解所在方法名区分不同的限流策略

    //获取rateLimiter
     if(map.containsKey(functionName)){
         rateLimiter = map.get(functionName);
     }else {
         map.put(functionName, RateLimiter.create(limitNum));
         rateLimiter = map.get(functionName);
     }

    try {
        if (rateLimiter.tryAcquire()) {
            //执行方法
            obj = joinPoint.proceed();
        } else {
            //拒绝了请求（服务降级）
            String result = objectMapper.writeValueAsString(MyResult.Error(500, "系统繁忙！"));
            log.info("拒绝了请求：" + result);
            outErrorResult(result);
        }
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }
    return obj;
}
//将结果返回
public void outErrorResult(String result) {
    response.setContentType("application/json;charset=UTF-8");
    try (ServletOutputStream outputStream = response.getOutputStream()) {
        outputStream.write(result.getBytes("utf-8"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

static {
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
}

}
二 测试限流
2个接口设定没秒限流5个和美妙限流10个
@RateLimit(limitNum = 5.0)
public MyResult getResults() {
log.info("调用了方法getResults");
return MyResult.OK("调用了方法", null);
}

@RateLimit(limitNum = 10.0)
public MyResult getResultTwo() {
    log.info("调用了方法getResultTwo");
    return MyResult.OK("调用了方法getResultTwo", null);

}