java接口限流方案以及应用框架

spring-boot-starter-data-redis-reactive 是 Spring Boot 提供的一个 Starter 依赖，用于集成响应式 Redis 客户端，支持基于响应式编程模型（如 Reactor）操作 Redis 数据库。它是 Spring Data Redis 针对响应式编程场景的实现，与传统的同步阻塞式 Redis 客户端（如 Lettuce、Jedis）相比，核心特

qq_33803292

703人浏览 · 2025-10-31 16:19:49

qq_33803292 · 2025-10-31 16:19:49 发布

1. Guava RateLimiter（本地限流）

核心原理

基于令牌桶算法的本地限流工具，通过预生成令牌控制请求频率：

系统按固定速率（如每秒5个）向桶中放入令牌；
每个请求需获取1个令牌才能执行，无令牌则被限流；
支持「突发流量」（桶内可预存令牌，超出速率的短期请求可消耗存量令牌）。
桶有最大容量，令牌满了之后不再生成（避免无限制累积）。

Maven依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version> <!-- 稳定版本 -->
</dependency>

Java应用示例

import com.google.common.util.concurrent.RateLimiter;

public class GuavaRateLimiterDemo {
    public static void main(String[] args) {
        // 配置：每秒生成3个令牌（QPS=3）
        RateLimiter rateLimiter = RateLimiter.create(3.0);

        // 模拟10次请求
        for (int i = 0; i < 10; i++) {
            // 非阻塞获取令牌（立即返回结果）
            boolean canPass = rateLimiter.tryAcquire();
            if (canPass) {
                System.out.println("请求" + (i + 1) + "：处理成功（获取令牌）");
            } else {
                System.out.println("请求" + (i + 1) + "：被限流（无令牌）");
            }
        }
    }
}

输出说明：前3次请求成功，后续请求因无令牌被限流（体现每秒3个QPS的控制）。

2. Redisson RRateLimiter（分布式限流）

核心原理

基于Redis的分布式令牌桶，解决多实例集群限流一致性问题：

令牌生成逻辑由Redis维护，所有实例共享同一令牌桶；
支持两种模式：OVERALL（全局限流，所有实例共享阈值）和PER_CLIENT（按客户端限流）；
通过Redis原子操作（如INCR、EXPIRE）保证计数准确性，避免分布式并发问题。

Maven依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.3</version> <!-- 兼容主流Spring Boot版本 -->
</dependency>

Java应用示例

import org.redisson.api.RRateLimiter;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedissonRateLimiterDemo implements CommandLineRunner {

    @Autowired
    private RedissonClient redissonClient;

    public static void main(String[] args) {
        SpringApplication.run(RedissonRateLimiterDemo.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // 定义限流标识（如接口名）
        String limitKey = "order_submit_api";
        
        // 获取限流器
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(limitKey);
        
        // 配置：全局限流，每秒生成5个令牌，桶容量5（不允许突发）
        rateLimiter.trySetRate(RateType.OVERALL, 5, 1, RateType.SECONDS);

        // 模拟8次请求
        for (int i = 0; i < 8; i++) {
            boolean canPass = rateLimiter.tryAcquire(1); // 获取1个令牌
            System.out.println("请求" + (i + 1) + (canPass ? "：成功" : "：被限流"));
        }
    }
}

注意：需配置Redis地址（在application.yml中），示例仅展示核心逻辑。

3. Spring Cloud Gateway 限流（网关层限流）

核心原理

基于Redis令牌桶的网关层集中限流，在请求到达业务服务前拦截：

通过RequestRateLimiter过滤器集成限流逻辑；
支持多维度限流（IP、用户ID、接口路径等），通过KeyResolver定义限流维度；
依赖响应式Redis客户端（spring-boot-starter-data-redis-reactive）与Redis交互。

Maven依赖

<!-- Spring Cloud Gateway -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
    <version>3.1.8</version> <!-- 兼容Spring Boot 2.7.x -->
</dependency>

<!-- 响应式Redis（用于限流计数） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
    <version>2.7.17</version>
</dependency>

Java应用示例

① 配置文件（application.yml）

spring:
  redis:
    host: localhost
    port: 6379
  cloud:
    gateway:
      routes:
        - id: user_service
          uri: http://localhost:8081  # 目标业务服务地址
          predicates:
            - Path=/api/user/**  # 拦截的接口路径
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10  # 每秒生成10个令牌
                redis-rate-limiter.burstCapacity: 20  # 最大突发20个令牌
                key-resolver: "#{@ipKeyResolver}"  # 按IP限流

② 配置类（定义限流维度）

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;

@Configuration
public class GatewayRateLimitConfig {

    // 按请求IP作为限流Key
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            // 获取客户端IP地址
            exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
        );
    }
}

③ 启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

效果：同一IP每秒最多处理10个请求，短时间突发不超过20个。

4. Sentinel（分布式流量治理）

是阿里巴巴开源的分布式系统流量治理框架，核心目标是保障服务稳定性，通过限流、熔断、降级等手段，防止因流量突增、服务依赖故障等导致的系统雪崩。它具有轻量级、高可用、易集成等特点，广泛应用于微服务架构中

核心原理

基于滑动窗口算法的分布式限流框架，支持限流、熔断、降级一体化：

以“资源”（如接口方法、URL）为单位定义规则，通过滑动窗口统计请求数；
窗口划分为多个小格子（如1秒=10个100ms格子），动态计算最近窗口内的请求量；
支持集群限流（需部署Sentinel控制台和Token Server），适合微服务架构。

Sentinel 架构组成

Sentinel 由 **客户端 **和 **控制台 **两部分组成：
客户端：嵌入应用内部，负责资源埋点、流量统计、规则判断和限流熔断执行（核心依赖 sentinel-core）。
控制台（Dashboard）：独立部署的可视化平台，用于配置规则、监控实时流量、查看熔断状态等（支持动态推送规则到客户端）。

Maven依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.6</version> <!-- 稳定版本 -->
</dependency>
<!-- Spring Boot 集成依赖（自动埋点 Spring MVC 接口） -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-boot-starter</artifactId>
    <version>1.8.6</version>
</dependency>
<!-- 若需控制台监控，添加此依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.6</version>
</dependency>

Java应用示例

方式1 手动配置规则

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import java.util.ArrayList;
import java.util.List;

public class SentinelDemo {
    // 定义资源名（通常为接口或方法名）
    private static final String RESOURCE_NAME = "product_query_api";

    public static void main(String[] args) {
        // 初始化限流规则
        initFlowRules();

        // 模拟10次请求
        for (int i = 0; i < 10; i++) {
            try (Entry entry = SphU.entry(RESOURCE_NAME)) {
                // 被保护的业务逻辑
                System.out.println("请求" + (i + 1) + "：查询商品成功");
            } catch (BlockException e) {
                // 限流时的处理（如返回友好提示）
                System.out.println("请求" + (i + 1) + "：被限流（流量超限）");
            }
        }
    }

    // 配置限流规则：QPS上限为4
    private static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource(RESOURCE_NAME); // 关联资源
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 按QPS限流
        rule.setCount(4); // QPS上限4
        rules.add(rule);
        FlowRuleManager.loadRules(rules); // 加载规则
    }
}

输出说明：前4次请求成功，后续因QPS超限被限流。

方式2 注解埋点

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    // 定义资源 "createOrder"，限流时调用 blockHandler 方法
    @SentinelResource(
        value = "createOrder",
        blockHandler = "createOrderBlockHandler", // 限流/熔断时的兜底方法
        fallback = "createOrderFallback" // 业务异常时的兜底方法（可选）
    )
    @GetMapping("/order/create")
    public String createOrder() {
        // 模拟业务逻辑
        return "订单创建成功";
    }

    // 限流/熔断时的兜底方法（参数和返回值需与原方法一致，额外加 BlockException 参数）
    public String createOrderBlockHandler(BlockException e) {
        return "系统繁忙，请稍后再试（限流/熔断）";
    }

    // 业务异常时的兜底方法（参数和返回值需与原方法一致）
    public String createOrderFallback() {
        return "订单创建失败（业务异常）";
    }
}

总结

框架	核心场景	依赖	优势
Guava RateLimiter	单实例简单限流	无额外依赖	轻量、易用，适合单机场景
Redisson	分布式集群限流	Redis	支持分布式一致性，API简单
Spring Cloud Gateway	微服务网关限流	Redis、网关	集中式管控，无业务侵入
Sentinel	分布式流量治理	可选控制台	限流+熔断一体化，功能全面