一、需求背景

核心訴求：

• 支持自定義統(tǒng)計窗口
  需要實現(xiàn)不定長統(tǒng)計窗口的限流，比如半小時一次。
• 支持分布式
  由于可能限定的流量為一次，需要分布式支持。
• 支持注解
  簡化使用。
• 支持動態(tài)參數(shù)
  需要根據(jù)方法參數(shù)做細粒度的限流。

二、方案對比

對比寫的比較淺顯，僅體現(xiàn)當前需求，實際需要考慮的因素會很多，其它方案也有很多。

簡單總結：

1. Guava 使用簡單，缺少分布式和注解等支持。
2. Sentinel 功能強大，但是考慮到需求并非通用限流模式，導致整體實現(xiàn)起來較復雜。
3. Redisson 使用簡單，支持分布式，缺少注解等支持。

最后選擇 Redisson 方案，使用簡單，補全缺少的功能的實現(xiàn)也不復雜。

三、Redisson 實現(xiàn)

• Spring Boot 2.x
• Jdk 1.8

1、添加依賴

注意依賴的版本，參考官網(wǎng)。

     <dependency>
         <groupId>org.redisson</groupId>
         <artifactId>redisson-spring-boot-starter</artifactId>
         <version>2.15.2</version>
     </dependency>

2、添加配置

支持多種配置方法，參考官網(wǎng)。

spring:
  redis:
    password: xxxxxxxx
    cluster:
      nodes:
        - xxx.xxx.xxx.xxx:6379
        - xxx.xxx.xxx.xxx:6379

3、添加自定義注解和AOP實現(xiàn)

自定義注解，key 值為限流全局唯一標識，支持 Spel 表達式。

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    // 唯一標識
    String key() default "";

    // 限制流量
    int rate() default 1;

    // 統(tǒng)計窗口 (單位秒)
    int interval() default 1;

}

具體限流AOP實現(xiàn)如下，主要包括 key值解析，和限流邏輯。

限流邏輯：

• 邏輯比較簡單，需要注意的是，如果程序限流配置變更，需要自行刪除 Redis 中舊的配置，當然也是可以添加獲取、對比和刪除配置的邏輯，就是性能上有點影響。
• 可根據(jù)實際需要添加更多功能，比如分布式限流失敗，降級為單機限流。

Key值解析：

• 將方法的所有參數(shù)封裝到一個 Map 對象中。
• 在key值做進一步解析前，將其格式轉變成存在于Map對象內，類似 user.id 轉換為 ['user'].id。

@Aspect
@Component
@Slf4j
@RequiredArgsConstructor
public class RateLimitAspect {

    public static final String RATE_LIMITER_KEY_PREFIX = "rate-limiter:";
    private final RedissonClient redissonClient;


    @Around("@annotation(rateLimit)")
    private Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        String key = getKey(joinPoint, rateLimit);
        log.info("rate limiter key: {}", key);

        // Key為空，不做限流
        if (key == null) {
            return joinPoint.proceed();
        }

        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        if (!rateLimiter.isExists()) {
            // 如果配置變更，需要先刪除Redis中舊的配置
            rateLimiter.trySetRate(RateType.OVERALL, rateLimit.rate(), rateLimit.interval(), RateIntervalUnit.SECONDS);
        }

        if (!rateLimiter.tryAcquire()) {
            throw new RRException("操作過于頻繁，請稍后再試");
        }

        return joinPoint.proceed();
    }

    private String getKey(ProceedingJoinPoint joinPoint, RateLimit rateLimit) {
        String key = rateLimit.key();
        if (StringUtils.isEmpty(key)) {
            return null;
        }

        String parsedKey;
        try {
            parsedKey = ExprUtils.parse(key, getArgsMap(joinPoint));
        } catch (Throwable e) {
            log.error("parse rate limiter's key failed", e);
            return null;
        }
        return RATE_LIMITER_KEY_PREFIX + parsedKey;
    }

    private Map<String, Object> getArgsMap(ProceedingJoinPoint joinPoint) {
        String[] names = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
        Object[] args = joinPoint.getArgs();

        Map<String, Object> argsMap = new HashMap<>(names.length);
        for (int i = 0; i < names.length; i++) {
            argsMap.put(names[i], args[i]);
        }
        return argsMap;
    }
}

public class ExprUtils {

    private static final ExpressionParser parser = new RateLimitExpressionParser();
    private static final SimpleEvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();


    public static String parse(String expressionString, Map<String, Object> rootObject) {
        return parser.parseExpression(expressionString, TEMPLATE_EXPRESSION).getValue(context, rootObject, String.class);
    }


    private static class RateLimitExpressionParser extends SpelExpressionParser {

        @Override
        protected SpelExpression doParseExpression(String expressionString, @Nullable ParserContext context) throws ParseException {
            return super.doParseExpression(wrapWithMap(expressionString), context);
        }

        private String wrapWithMap(String expressionString) {
            int dotIndex = expressionString.indexOf(".");
            if (dotIndex > 0) {
                return "['" + expressionString.substring(0, dotIndex) + "']" + expressionString.substring(dotIndex - 1);
            }
            return "['" + expressionString + "']";
        }
    }

}

4、配置使用

一個簡單的查詢用戶信息的服務實現(xiàn)，限制每個用戶每5分鐘只能訪問1次。

@Service
public class InspectionTriggerServiceImpl implements InspectionTriggerService {

    @Override
    @RateLimit(key = "test-demo:user-service:get-#{user.id}", rate = 1, interval = 5 * 60)
    public UserVO get(UserBO user) {
        // ...
    }

}

四、總結

該方案適合簡單的場景，如果是復雜的場景，還是推薦使用 Sentinel 實現(xiàn)。