基于 Redisson 实现分布式系统下的接口限流

在高并发场景下，接口限流是保障系统稳定性的重要手段。常见的限流算法有漏桶算法、令牌桶算法等，而单机模式的限流方案在分布式集群环境下往往失效。本文将介绍如何利用 Redisson 结合 Redis 实现分布式环境下的接口限流，确保集群中所有节点的流量控制保持一致。

分布式限流的核心挑战

在单机系统中，我们可以通过本地缓存（如 Guava 的 RateLimiter）实现限流，但在分布式集群环境下，这种方案会遇到两个核心问题：

• 集群节点间的限流状态不共享，导致整体流量超过预期阈值
• 无法保证同一用户 / IP 的请求在不同节点上被统一限制

因此，分布式限流需要一个「中心化的状态存储」来记录流量数据，而 Redis 凭借其高并发特性和分布式特性，成为了理想的选择。

基于 Redisson 的分布式限流设计思路

核心原理是通过 Redis 记录每个用户对接口的访问频率，利用分布式锁实现并发控制，具体设计如下：

1. 唯一标识用户与接口
   为了避免限制 A 用户时影响 B 用户，需要为每个用户 + 接口组合生成唯一的「限流键」。

   一般为用户：使用 token + 接口路径 +用户的id

2. 基于 Redis 的访问频率记录
   每次请求到来时，通过 Redisson 操作 Redis 记录访问时间，并检查单位时间内的访问次数是否超过阈值。

3. AOP 无侵入式拦截
   通过自定义注解 + Spring AOP 拦截需要限流的接口，在请求到达时执行限流逻辑，不侵入业务代码。

4. 自动过期的限流状态
   为 Redis 中的限流键设置过期时间，避免长期存储无效数据，同时确保超过限制时间后自动允许用户再次访问。

实现步骤

引入依赖

在 pom.xml 中添加 Redisson 和 AOP 依赖

<!-- Redisson 分布式工具 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.3</version>
</dependency>

<!-- Spring AOP -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

定义限流注解

创建 @NoRepeatSubmit 注解，用于标记需要限流的接口，并支持自定义限流参数：

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

    /**
     * 设置请求锁定时间(秒)
     */
    int lockTime() default 5;
}

实现限流切面

通过 AOP 拦截 @NoRepeatSubmit 注解的方法，使用 Redisson 操作 Redis 实现限流逻辑：

Aspect
@Component
public class RepeatSubmitAspect {

    private static final Logger log = LoggerFactory.getLogger(RepeatSubmitAspect.class);

    @Resource
    private RedissonClient redissonClient;

    @Pointcut("@annotation(com.example.demo.config.NoRepeatSubmit)")
    public void pointCut() {
    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        NoRepeatSubmit annotation = method.getAnnotation(NoRepeatSubmit.class);

        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            throw new IllegalArgumentException("无法获取请求信息");
        }

        HttpServletRequest request = attributes.getRequest();
        String token = request.getHeader("token");
        String path = request.getServletPath();

        if (token == null || token.isEmpty()) {
            throw new IllegalArgumentException("缺少token请求头");
        }

        // 使用token+path作为锁的key
        String key = "repeat_submit:" + token + ":" + path;
        RLock lock = redissonClient.getLock(key);

        // 尝试获取锁，等待0秒，自动释放时间由注解指定
        boolean isSuccess = false;
            isSuccess = lock.tryLock(0, annotation.lockTime(), TimeUnit.SECONDS);
            if (isSuccess) {
                log.info("获取锁成功: {}", key);
                // 执行目标方法
                return pjp.proceed();
            } else {
                log.info("重复请求，获取锁失败: {}", key);
                return Result.fail("请勿重复提交请求");
            }
    }
}

测试

@RestController
@RequestMapping("/api/order")
public class OrderController {

    @PostMapping("/create")
    @NoRepeatSubmit(lockTime = 10) // 设置5秒内不允许重复提交
    public Result createOrder() {
        // 模拟订单创建过程
        try {
            Thread.sleep(2000); // 模拟业务处理耗时2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return Result.success("订单创建成功");
    }
}

限制之后

这里还可以增加更多的逻辑，比如限制次数等等。

核心逻辑说明

1. 用户唯一标识生成
   通过 getUniqueUserKey 方法获取用户标识：已登录用户用 token，未登录用户用 IP，确保不同用户的限流互不干扰。
2. 限流键设计
   限流键格式为 rate_limit:用户标识:接口路径，例如 rate_limit:test_token:/api/order/submit，精确控制「用户 + 接口」的访问频率。
3. 分布式锁的作用
   由于 Redis 的 INCR 操作虽然原子，但在高并发下可能出现「读取 - 判断 - 更新」的竞态条件，因此通过 Redisson 分布式锁确保计数逻辑的原子性。
4. 自动过期机制
   每个限流键都设置了与时间窗口相同的过期时间，避免 Redis 中存储大量无效数据，同时确保时间窗口结束后自动重置计数。
   由于 Redis 的 INCR 操作虽然原子，但在高并发下可能出现「读取 - 判断 - 更新」的竞态条件，因此通过 Redisson 分布式锁确保计数逻辑的原子性。
5. 自动过期机制
   每个限流键都设置了与时间窗口相同的过期时间，避免 Redis 中存储大量无效数据，同时确保时间窗口结束后自动重置计数。