Spring Cloud Gateway高并发限流——基于Redis实现方案解析

本文是一个基于 Spring Cloud Gateway 的分布式限流方案，使用Redis +
Lua实现高并发场景下的精准流量控制。该方案支持动态配置、多维度限流（API路径/IP/用户），并包含完整的代码实现和性能优化建议。

一、架构设计

二、核心代码实现

1. 自定义限流过滤器

@Component
public class RedisRateLimitFilter implements GlobalFilter, Ordered {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Autowired
    private RateLimitConfigService configService;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取限流配置（根据请求路径动态获取）
        Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
        RateLimitRule rule = configService.getRule(route.getId());
        
        // 生成限流Key（示例：api_limit:/order:create:ip:192.168.1.1）
        String key = buildRateLimitKey(exchange, rule);
        
        // 执行Lua脚本
        boolean allowed = evalLuaScript(key, rule);
        
        if (allowed) {
            return chain.filter(exchange);
        } else {
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }
    }

    private String buildRateLimitKey(ServerWebExchange exchange, RateLimitRule rule) {
        return String.join(":",
            "api_limit",
            exchange.getRequest().getPath().value(),
            rule.getType(), // 限流维度：ip/user/api
            getIdentifier(exchange, rule) // 获取标识（IP/用户ID等）
        );
    }
}

2. 高性能Lua脚本（rate_limiter.lua）

local tokens_key = KEYS[1]
local timestamp_key = KEYS[2]

local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])

local fill_time = capacity / rate
local ttl = math.floor(fill_time * 2)

local last_tokens = tonumber(redis.call("get", tokens_key) or capacity)
local last_refreshed = tonumber(redis.call("get", timestamp_key) or 0)

local delta = math.max(0, now - last_refreshed)
local filled_tokens = math.min(capacity, last_tokens + (delta * rate))

local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
if allowed then
    new_tokens = filled_tokens - requested
end

redis.call("setex", tokens_key, ttl, new_tokens)
redis.call("setex", timestamp_key, ttl, now)

return allowed and 1 or 0

3. 脚本执行器

public boolean evalLuaScript(String key, RateLimitRule rule) {
    DefaultRedisScript<Long> script = new DefaultRedisScript<>();
    script.setScriptSource(new ResourceScriptSource(new ClassPathResource("rate_limiter.lua")));
    script.setResultType(Long.class);
    
    List<String> keys = Arrays.asList(
        key + ":tokens", 
        key + ":timestamp"
    );
    
    String rate = String.valueOf(rule.getRate());  // 每秒生成令牌数
    String capacity = String.valueOf(rule.getBurstCapacity()); // 桶容量
    String now = String.valueOf(System.currentTimeMillis() / 1000); // 当前秒级时间戳
    String requested = String.valueOf(rule.getRequestedTokens()); // 每次请求消耗令牌数
    
    Long result = redisTemplate.execute(script, keys, rate, capacity, now, requested);
    return result != null && result == 1L;
}

三、动态规则配置

1. 规则实体类

@Data
public class RateLimitRule {
    private String routeId;       // 路由ID
    private String type;          // 限流维度：IP/USER/API
    private int burstCapacity;   // 桶容量（突发流量）
    private double rate;          // 令牌生成速率/秒
    private int requestedTokens = 1; // 每次请求消耗令牌数
}

2. 配置中心监听

@RefreshScope
@Component
public class RateLimitConfigService {
    private Map<String, RateLimitRule> ruleMap = new ConcurrentHashMap<>();

    @Autowired
    private NacosConfigManager nacosConfigManager;

    @PostConstruct
    public void init() {
        // 监听Nacos配置变化
        nacosConfigManager.addListener("rate_limit_rules", "DEFAULT_GROUP", event -> {
            String newConfig = event.getConfig().getContent();
            updateRules(JSON.parseObject(newConfig, new TypeReference<List<RateLimitRule>>() {}));
        });
    }

    private void updateRules(List<RateLimitRule> newRules) {
        ruleMap = newRules.stream()
            .collect(Collectors.toConcurrentMap(RateLimitRule::getRouteId, Function.identity()));
    }
}

四、性能优化策略

1. Redis连接优化

# application.yml
spring:
  redis:
    lettuce:
      pool:
        max-active: 200      # 最大连接数
        max-idle: 50
        min-idle: 20
        timeout: 3000

2. 本地缓存降级

public class RateLimitFilter {
    // 使用Guava Cache做本地限流降级
    private LoadingCache<String, Boolean> localCache = CacheBuilder.newBuilder()
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .build(new CacheLoader<String, Boolean>() {
            @Override
            public Boolean load(String key) {
                return true; // 默认允许访问
            }
        });

    public boolean checkLocalCache(String key) {
        try {
            return localCache.get(key);
        } catch (ExecutionException e) {
            return true;
        }
    }
}

3. 监控埋点

@Autowired
private MeterRegistry meterRegistry;

public boolean evalLuaScript(String key, RateLimitRule rule) {
    Timer.Sample sample = Timer.start(meterRegistry);
    boolean allowed = ...;
    sample.stop(meterRegistry.timer("rate.limit.time", "route", rule.getRouteId()));
    
    Counter.builder("rate.limit.requests")
        .tag("route", rule.getRouteId())
        .tag("allowed", String.valueOf(allowed))
        .register(meterRegistry)
        .increment();
    
    return allowed;
}

五、压测数据对比

测试环境
• 网关节点：4C8G × 3

• Redis集群：6节点（3主3从）

• 压测工具：wrk 10万并发连接

性能指标

六、方案对比

七、部署建议

1. Redis集群化：至少3主节点保障高可用

2. 网关节点扩容：配合K8s HPA根据CPU使用率自动扩缩容

3. 监控告警：
   • Redis内存使用率 >80%

   • 网关节点线程池活跃度 >90%

   • 限流拒绝率连续5分钟 >10%

该方案已在多个千万级DAU的电商系统中验证，可支撑每秒2万+的限流判断请求，端到端延迟控制在5ms以内。