分布式场景限流-redission

Redis限流-redission

定义限流类型

public enum LimitType {
   
    /**
     * 默认策略全局限流
     */
    DEFAULT,

    /**
     * 根据请求者IP进行限流
     */
    IP,
    /**
     * 令牌桶限流
     */
    TOKEN_BUCKET,
}

定义限流自定义注解

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

    int limitValue() default 10; // 每秒允许的请求数

    int maxConcurrentRequests() default 2; // 最大并发请求数

    String key() default ""; // 限流的唯一标识，支持SpEL表达式

    LimitType limitType() default LimitType.DEFAULT; // 限流的类型

    String message() default "前方拥挤,请稍后再试"; // 限流提示信息

    boolean failFast() default true; // 是否快速失败
}

使用Spring AOP进行前置拦截

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

    private final RedisRateLimiter redisRateLimiter;
    private ExpressionParser parser = new SpelExpressionParser();
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();

    @Around("@annotation(rateLimit)")
    public Object limit(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
   
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();

        Method method = signature.getMethod();
        String methodName = method.getName();
        String uniqueKey = getUniqueKey(methodName, joinPoint, rateLimit);
        log.info("方法：{} 限流key：{} 限流开始", methodName, uniqueKey);
        boolean acquired = redisRateLimiter.acquireForRedisson(methodName, rateLimit, uniqueKey);
        if (!acquired) {
   
            log.error("方法：{} 触发限流，限流key：{}", methodName, uniqueKey);
            throw new RateLimitExceededException(rateLimit.message());
        }
        try {
   
            return joinPoint.proceed();
        } finally {
   
            redisRateLimiter.release(methodName, uniqueKey);
            log.info("方法：{} 限流key：{} 限流正常结束", methodName, uniqueKey);
        }
    }

    private String