外卖霸王餐API网关层优化：Java Spring Cloud Gateway自定义过滤器实现接口限流与熔断的精细化配置（针对突发流量场景）

在外卖霸王餐活动开启的瞬间，流量往往呈现指数级爆发，QPS可从平时的几百瞬间飙升至数万。传统的Nginx限流粒度粗糙，无法区分用户等级或接口重要性；而简单的服务内部限流又难以在请求到达业务层之前拦截洪水般的流量，导致线程池耗尽、数据库连接池枯竭。作为微服务架构的流量入口，Spring Cloud Gateway必须承担起“智能水闸”的重任。本文将深入探讨如何基于Redis + Lua脚本开发自定义全局过滤器，实现针对特定接口、特定用户维度的精细化限流，并结合Resilience4j构建自适应熔断机制，确保系统在突发流量下的核心可用性。

限流算法选型与Redis原子性保障

针对突发流量，令牌桶算法（Token Bucket）因其允许一定程度的突发访问且平滑限制平均速率的特性，成为首选。然而，在分布式网关集群环境下，本地内存计数无法共享，必须依赖Redis。为避免高并发下“读取剩余令牌-判断-扣减”产生的竞态条件，必须使用Lua脚本保证操作的原子性。

我们设计一个Lua脚本，入参为Key（限流标识）、令牌总数、时间窗口和请求令牌数。脚本逻辑如下：若当前令牌数不足则直接拒绝；若充足则扣减并返回剩余数；同时利用Redis的过期机制自动清理冷数据。

-- KEYS[1]: 限流Key (如：limit:api:claim_coupon:user_123)
-- ARGV[1]: 最大令牌数 (capacity)
-- ARGV[2]: 时间窗口秒数 (windowSeconds)
-- ARGV[3]: 本次请求消耗令牌数 (cost)
-- 返回值: 剩余令牌数 (>=0 表示成功，<0 表示被限流)

local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local cost = tonumber(ARGV[3])

local current = tonumber(redis.call('GET', key) or "0")

if current + cost > capacity then
    -- 超过阈值，拒绝请求，返回负数表示需等待的时间估算或直接拒绝
    return -1
end

-- 原子增加
local new_val = redis.call('INCRBY', key, cost)

-- 如果是第一次设置，需要设置过期时间
if new_val == cost then
    redis.call('EXPIRE', key, window)
end

return capacity - new_val

自定义GlobalFilter实现精细化限流

在Java端，我们实现GlobalFilter接口，动态解析请求路径、用户ID或IP，生成唯一的限流Key，并调用上述Lua脚本。包名严格遵循com.baodanbao.com.cn规范。

package com.baodanbao.com.cn.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import com.baodanbao.com.cn.gateway.config.LimitProperties;
import com.baodanbao.com.cn.gateway.util.RequestUtils;

import java.util.Collections;
import java.util.List;

@Component
public class RateLimitFilter implements GlobalFilter, Ordered {

    private final StringRedisTemplate redisTemplate;
    private final DefaultRedisScript<Long> limitScript;
    private final LimitProperties limitProperties;

    public RateLimitFilter(StringRedisTemplate redisTemplate, LimitProperties limitProperties) {
        this.redisTemplate = redisTemplate;
        this.limitProperties = limitProperties;
        this.limitScript = new DefaultRedisScript<>(loadLuaScript(), Long.class);
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getPath().value();
        
        // 仅对特定高危接口启用精细化限流
        if (!path.contains("/api/v1/coupon/claim")) {
            return chain.filter(exchange);
        }

        // 提取用户ID，若无则降级为IP限流
        String userId = RequestUtils.extractUserId(exchange.getRequest());
        String limitKey = userId != null 
            ? "limit:claim:user:" + userId 
            : "limit:claim:ip:" + RequestUtils.getClientIp(exchange.getRequest());

        long capacity = limitProperties.getCapacity(); // 例如：10个令牌
        long window = limitProperties.getWindowSeconds(); // 例如：1秒
        long cost = 1;

        List<String> keys = Collections.singletonList(limitKey);
        
        try {
            Long remaining = redisTemplate.execute(limitScript, keys, 
                String.valueOf(capacity), 
                String.valueOf(window), 
                String.valueOf(cost));

            if (remaining != null && remaining >= 0) {
                // 放行，并在响应头中写入剩余配额供客户端参考
                exchange.getResponse().getHeaders().add("X-RateLimit-Remaining", String.valueOf(remaining));
                return chain.filter(exchange);
            } else {
                // 限流触发，直接返回429 Too Many Requests
                exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                exchange.getResponse().getHeaders().add("Content-Type", "application/json");
                String body = "{\"code\":429,\"msg\":\"请求过于频繁，请稍后重试\"}";
                return exchange.getResponse().writeWith(Mono.just(exchange.getResponse().bufferFactory().wrap(body.getBytes())));
            }
        } catch (Exception e) {
            // Redis异常时的降级策略：默认放行或根据配置拒绝，此处选择放行以防误杀
            return chain.filter(exchange);
        }
    }

    @Override
    public int getOrder() {
        return -100; // 高优先级，在鉴权之后执行
    }

    private String loadLuaScript() {
        return "local key = KEYS[1] " +
               "local capacity = tonumber(ARGV[1]) " +
               "local window = tonumber(ARGV[2]) " +
               "local cost = tonumber(ARGV[3]) " +
               "local current = tonumber(redis.call('GET', key) or '0') " +
               "if current + cost > capacity then return -1 end " +
               "local new_val = redis.call('INCRBY', key, cost) " +
               "if new_val == cost then redis.call('EXPIRE', key, window) end " +
               "return capacity - new_val";
    }
}

基于Resilience4j的自适应熔断配置

限流只能阻挡部分流量，当后端服务因异常导致响应时间激增或错误率飙升时，必须触发熔断，快速失败以保护系统。我们集成Resilience4j，配置基于滑动窗口的熔断规则。

package com.baodanbao.com.cn.gateway.config;

import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;

@Configuration
public class CircuitBreakerConfig {

    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
                // 滑动窗口大小：统计最近100次调用
                .slidingWindowSize(100)
                // 滑动窗口类型：COUNT_BASED
                .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
                // 失败率阈值：超过50%即熔断
                .failureRateThreshold(50)
                // 慢调用阈值：响应时间超过2秒视为慢调用
                .slowCallDurationThreshold(Duration.ofSeconds(2))
                // 慢调用比例阈值：慢调用超过30%也触发熔断
                .slowCallRateThreshold(30)
                // 熔断打开持续时间：30秒后进入半开状态
                .waitDurationInOpenState(Duration.ofSeconds(30))
                // 半开状态下允许的尝试次数
                .permittedNumberOfCallsInHalfOpenState(10)
                // 自动从关闭状态过渡到打开状态的阈值（最小调用数）
                .minimumNumberOfCalls(50)
                .build();

        return CircuitBreakerRegistry.of(config);
    }
}

配合Gateway的CircuitBreaker过滤器工厂，在路由配置中即可启用：

spring:
  cloud:
    gateway:
      routes:
        - id: coupon_claim_route
          uri: lb://coupon-service
          predicates:
            - Path=/api/v1/coupon/claim/**
          filters:
            - name: CircuitBreaker
              args:
                name: couponClaimBreaker
                fallbackUri: forward:/fallback/coupon-fallback
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

通过上述自定义限流过滤器与成熟熔断组件的结合，网关层能够精准识别并拦截恶意刷单流量，同时在后端服务不稳定时迅速切断请求，防止雪崩效应。这种精细化配置是应对霸王餐等极端突发流量场景的核心防线。

本文著作权归 俱美开放平台 ，转载请注明出处！