SpringBoot接口 - 如何实现接口限流之分布式

上文中介绍了单实例下如何在业务接口层做限流，本文主要介绍分布式场景下限流的方案，以及什么样的分布式场景下需要在业务层加限流而不是接入层; 并且结合开源的ratelimiter-spring-boot-starter在新窗口打开为例，作者是kailing， 学习思路+代码封装+starter封装。

• SpringBoot接口 - 如何实现接口限流之分布式
  • 准备知识点
  • 实现思路之redis+lua封装
    • 使用场景：为什么有些分布式场景下，还会在代码层进行控制限流？
    • 源代码的要点
    • 1、快速开始
      • 1.1、添加组件依赖，已上传到maven中央仓库
      • 1.2、application.properties 配置
      • 1.3、在需要加限流逻辑的方法上，添加注解 @RateLimit，如：
        • 1.3.1 @RateLimit 注解说明
        • 1.3.2 限流的粒度，限流 key
        • 1.3.3 触发限流后的行为
    • 2、进阶用法
      • 2.1、自定义限流的 key
        • 2.1.1、@RateLimitKey 的方式
        • 2.1.2、指定 keys 的方式
        • 2.1.3、自定义 key 获取函数
      • 2.2、自定义限流后的行为
        • 2.2.1、配置响应内容
        • 2.2.2、自定义限流触发异常处理器
        • 2.2.3、自定义触发限流处理函数，限流降级
      • 2.3 动态设置限流大小
        • 2.3.1、rateExpression 的使用
    • 3、集成示例、测验
      • 3.1、集成测验
      • 3.2、压力测试
    • 4、版本更新
      • 4.1、（v1.1.1）版本更新内容
      • 4.2、（v1.2）版本更新内容
  • 示例源码

# 准备知识点

上文我们提到了分布式限流的思路：

我们需要分布式限流和接入层限流来进行全局限流。

1. redis+lua实现中的lua脚本
2. 使用Nginx+Lua实现的Lua脚本
3. 使用 OpenResty 开源的限流方案
4. 限流框架，比如Sentinel实现降级限流熔断

# 实现思路之redis+lua封装

redis+lua是代码层实现较为常见的方案，网上有很多的封装， 我这里找一个给你分享下。以gitee开源的ratelimiter-spring-boot-starter在新窗口打开为例，作者是kailing， 值得初学者学习思路+代码封装+starter封装：

# 使用场景：为什么有些分布式场景下，还会在代码层进行控制限流？

基于 redis 的偏业务应用的分布式限流组件，使得项目拥有分布式限流能力变得很简单。限流的场景有很多，常说的限流一般指网关限流，控制好洪峰流量，以免打垮后方应用。这里突出偏业务应用的分布式限流的原因，是因为区别于网关限流，业务侧限流可以轻松根据业务性质做到细粒度的流量控制。比如如下场景，

• 案例一：

有一个公开的 openApi 接口， openApi 会给接入方派发一个 appId，此时，如果需要根据各个接入方的 appId 限流，网关限流就不好做了，只能在业务侧实现

• 案例二：

公司内部的短信接口，内部对接了多个第三方的短信通道，每个短信通道对流量的控制都不尽相同，假设有的第三方根据手机号和短信模板组合限流，网关限流就更不好做了

让我们看下，作者kailing是如何封装实现ratelimiter-spring-boot-starter的。

# 源代码的要点

• Redis 客户端采用redisson，AOP拦截方式

所以引入如下包

ext {
    redisson_Version = '3.15.1'
}

dependencies {
    compile "org.redisson:redisson:${redisson_Version}"
    compile 'org.springframework.boot:spring-boot-starter-aop'
    compileOnly 'org.springframework.boot:spring-boot-starter-web'

    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springdoc:springdoc-openapi-ui:1.5.2'
}

• RateLimit注解

作者考虑了时间表达式，限流后的自定义回退后的拒绝逻辑, 用户自定义Key（PS：这里其实可以加一些默认的Key生成策略，比如按照方法策略， 按照方法&IP 策略, 按照自定义策略等，默认为按照方法）

package com.taptap.ratelimiter.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author kl (http://kailing.pub)
 * @since 2021/3/16
 */
@Target(value = {ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface RateLimit {

    /**
     * 时间窗口流量数量
     * @return rate
     */
    long rate();

    /**
     * 时间窗口流量数量表达式
     * @return rateExpression
     */
    String rateExpression() default "";

    /**
     * 时间窗口，最小单位秒，如 2s，2h , 2d
     * @return rateInterval
     */
    String rateInterval();

    /**
     * 获取key
     * @return keys
     */
    String [] keys() default {};

    /**
     * 限流后的自定义回退后的拒绝逻辑
     * @return fallback
     */
    String fallbackFunction() default "";

    /**
     * 自定义业务 key 的 Function
     * @return key
     */
    String customKeyFunction() default "";

}

• AOP拦截

around环绕方式， 通过定义RateLimiterService获取方法注解的信息，存放在为RateLimiterInfo

如果还定义了回调方法，被限流后还会执行回调方法，回调方法也在RateLimiterService中。

package com.taptap.ratelimiter.core;

import com.taptap.ratelimiter.annotation.RateLimit;
import com.taptap.ratelimiter.exception.RateLimitException;
import com.taptap.ratelimiter.model.LuaScript;
import com.taptap.ratelimiter.model.RateLimiterInfo;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.redisson.api.RScript;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by kl on 2017/12/29.
 * Content : 切面拦截处理器
 */
@Aspect
@Component
@Order(0)
public class RateLimitAspectHandler {

    private static final Logger logger = LoggerFactory.getLogger(RateLimitAspectHandler.class);

    private final RateLimiterService rateLimiterService;
    private final RScript rScript;

    public RateLimitAspectHandler(RedissonClient client, RateLimiterService lockInfoProvider) {
        this.rateLimiterService = lockInfoProvider;
        this.rScript = client.getScript();
    }

    @Around(value = "@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        RateLimiterInfo limiterInfo = rateLimiterService.getRateLimiterInfo(joinPoint, rateLimit);

        List