微服务网关与流量治理：Gateway + Sentinel

@Override
protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
    // 1. 检查是否已设置 GATEWAY_HANDLER_MAPPER_ATTR
    if (this.managementPortType == DIFFERENT && this.managementPort != null
            && exchange.getRequest().getURI().getPort() == this.managementPort) {
        return Mono.empty();
    }
    
    // 2. 获取所有 Route
    exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, "true");
    
    return lookupRoute(exchange)
        .flatMap(route -> {
            // 3. 将匹配到的 Route 放入 Exchange 属性
            exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
            // 4. 返回 FilteringWebHandler
            return Mono.just(webHandler);
        }).switchIfEmpty(Mono.empty()
            .then(Mono.fromRunnable(() -> {
                // 5. 没有匹配到 Route，记录日志
                exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
            })));
}

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
    return this.routeLocator.getRoutes()
        .concatMap(route -> Mono.just(route)
            .filterWhen(r -> r.getPredicate().apply(exchange))
            .doOnError(e -> {})
            .onErrorResume(e -> Mono.empty())
        )
        .next()  // 取第一个匹配的
        .map(route -> {
            // 验证 Route
            validateRoute(route, exchange);
            return route;
        });
}

spring:
  cloud:
    gateway:
      routes:
        # 精确匹配放前面
        - id: order-detail
          uri: lb://order-service
          predicates:
            - Path=/api/order/detail/**
        # 通配匹配放后面
        - id: order-all
          uri: lb://order-service
          predicates:
            - Path=/api/order/**

public class PathRoutePredicateFactory extends AbstractRoutePredicateFactory<PathConfig> {
    @Override
    public Predicate<ServerWebExchange> apply(PathConfig config) {
        final List<PathPattern> pathPatterns = pathPatternParser.parse(config.getPatterns());
        
        return exchange -> {
            PathContainer path = parsePath(exchange.getRequest().getURI().getRawPath());
            // 匹配路径
            Optional<PathPattern> optionalPathPattern = pathPatterns.stream()
                .filter(pattern -> pattern.matches(path))
                .findFirst();
            
            if (optionalPathPattern.isPresent()) {
                PathPattern pathPattern = optionalPathPattern.get();
                // 将路径参数放入 Exchange 属性
                PathPattern.PathMatchInfo pathMatchInfo = pathPattern.matchAndExtract(path);
                putUriTemplateVariables(exchange, pathMatchInfo.getUriVariables());
                return true;
            }
            return false;
        };
    }
}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    // 1. 获取匹配的 Route
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    
    // 2. 获取该 Route 的 GatewayFilter 列表
    List<GatewayFilter> gatewayFilters = route.getFilters();
    
    // 3. 与 GlobalFilter 合并
    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    combined.addAll(gatewayFilters);
    
    // 4. 按 Order 排序
    AnnotationAwareOrderComparator.sort(combined);
    
    // 5. 构建响应式执行链
    return new DefaultGatewayFilterChain(combined).filter(exchange);
}

public Mono<Void> filter(ServerWebExchange exchange) {
    return Mono.defer(() -> {
        if (this.index < filters.size()) {
            GatewayFilter filter = filters.get(this.index);
            DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
            return filter.filter(exchange, chain);
        } else {
            return Mono.empty();
        }
    });
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - StripPrefix=1  # 去掉 /api，下游收到 /order/**

filters:
  - AddRequestHeader=X-Request-From, Gateway

filters:
  - RewritePath=/api/(?<segment>.*), /$\{segment}  # /api/order → /order

filters:
  - name: Retry
    args:
      retries: 3
      statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
      methods: GET,POST
      backoff:
        firstBackoff: 50ms
        maxBackoff: 500ms

RemoveCachedBodyFilter → AdaptCachedBodyGlobalFilter → ... → 
RouteToRequestUrlFilter → ReactiveLoadBalancerClientFilter → ... →
NettyRoutingFilter → NettyWriteResponseFilter

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
    String schemePrefix = exchange.getAttribute(GATEWAY_SCHEME_PREFIX_ATTR);
    
    if (url == null || (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
        return chain.filter(exchange);  // 不是 lb 协议，跳过
    }
    
    // 保留原始 URL
    addOriginalRequestUrl(exchange, url);
    
    // 负载均衡选择实例
    return choose(exchange).doOnNext(response -> {
        if (!response.hasServer()) {
            throw NotFoundException.create(true);
        }
        
        ServiceInstance instance = response.getServer();
        URI uri = exchange.getRequest().getURI();
        
        // 拼接实际请求地址
        String overrideScheme = instance.isSecure() ? "https" : "http";
        URI requestUrl = LoadBalancerUriTools.reconstructURI(
            new DelegatingServiceInstance(instance, overrideScheme), uri);
        
        exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);
    }).then(chain.filter(exchange));
}

protected Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
    URI uri = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
    String serviceId = uri.getHost();
    
    // 使用 Spring Cloud LoadBalancer
    return loadBalancer.choose(serviceId);
}

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);
    
    // 获取或创建 Netty HttpClient
    ServerHttpRequest request = exchange.getRequest();
    
    // 构建 Netty 请求
    final HttpMethod method = HttpMethod.valueOf(request.getMethodValue());
    final String url = requestUrl.toASCIIString();
    
    HttpClient httpClient = getHttpClient(route, exchange);
    
    // 发送请求
    Mono<HttpClientResponse> responseMono = httpClient.request(method)
        .uri(url)
        .send((req, nettyOutbound) -> {
            // 写入请求体
            return nettyOutbound.send(request.getBody()
                .map(dataBuffer -> 
                    ((NettyDataBuffer) dataBuffer).getNativeBuffer()));
        })
        .responseConnection((res, connection) -> {
            // 处理响应
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.valueOf(res.status().code()));
            response.getHeaders().putAll(getHeaders(res));
            
            // 将 Netty 响应体写入 ServerHttpResponse
            return response.writeWith(connection.inbound().receive()
                .retain()
                .map(buf -> exchange.getResponse().bufferFactory().wrap(buf)));
        });
    
    return responseMono.then(chain.filter(exchange));
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 1000  # 每秒填充 1000 个令牌
                redis-rate-limiter.burstCapacity: 2000  # 桶容量 2000
                redis-rate-limiter.requestedTokens: 1   # 每个请求消耗 1 个令牌
                key-resolver: "#{@ipKeyResolver}"       # 按 IP 限流

@Bean
public KeyResolver ipKeyResolver() {
    return exchange -> Mono.just(
        exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
    );
}

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))
if last_tokens == nil then
    last_tokens = capacity
end

local last_updated = tonumber(redis.call("get", timestamp_key))
if last_updated == nil then
    last_updated = 0
end

local delta = math.max(0, now - last_updated)
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

@Configuration
public class GatewayConfig {
    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;
    
    @PostConstruct
    public void init() {
        BlockExceptionHandler blockExceptionHandler = new JsonBlockExceptionHandler();
        GatewayCallbackManager.setBlockHandler(blockExceptionHandler);
    }
    
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
}

@PostConstruct
public void initRules() {
    Set<GatewayFlowRule> rules = new HashSet<>();
    
    // 1. 按 Route ID 限流
    rules.add(new GatewayFlowRule("order-service")
        .setCount(1000)
        .setIntervalSec(1));
    
    // 2. 按 API 分组限流
    rules.add(new GatewayFlowRule("order_api")
        .setCount(500)
        .setIntervalSec(1));
    
    // 3. 按请求参数限流（如按 Header 中的 AppId）
    rules.add(new GatewayFlowRule("order-service")
        .setCount(100)
        .setIntervalSec(1)
        .setParamItem(new GatewayParamFlowItem()
            .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_HEADER)
            .setFieldName("X-App-Id")));
    
    GatewayRuleManager.loadRules(rules);
    
    // 定义 API 分组
    Set<ApiDefinition> definitions = new HashSet<>();
    ApiDefinition api = new ApiDefinition("order_api")
        .setPredicateItems(new HashSet<>() {{
            add(new ApiPathPredicateItem().setPattern("/api/order/**"));
            add(new ApiPathPredicateItem().setPattern("/api/pay/**"));
        }});
    definitions.add(api);
    GatewayApiDefinitionManager.loadApiDefinitions(definitions);
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**

@Component
public class NacosRouteDefinitionRepository implements RouteDefinitionRepository {
    @Autowired
    private NacosConfigManager nacosConfigManager;
    
    private static final String DATA_ID = "gateway-routes";
    private static final String GROUP = "DEFAULT_GROUP";
    
    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        try {
            String config = nacosConfigManager.getConfigService()
                .getConfig(DATA_ID, GROUP, 5000);
            List<RouteDefinition> routes = parseRoutes(config);
            return Flux.fromIterable(routes);
        } catch (NacosException e) {
            return Flux.empty();
        }
    }
    
    @PostConstruct
    public void initListener() throws NacosException {
        nacosConfigManager.getConfigService().addListener(DATA_ID, GROUP, new Listener() {
            @Override
            public void receiveConfigInfo(String config) {
                // 配置变更，触发路由刷新
                List<RouteDefinition> routes = parseRoutes(config);
                // 发布 RefreshRoutesEvent
                applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this));
            }
            
            @Override
            public Executor getExecutor() {
                return null;
            }
        });
    }
    
    private List<RouteDefinition> parseRoutes(String config) {
        return JSON.parseArray(config, RouteDefinition.class);
    }
}

[
  {
    "id": "order-service",
    "predicates": [
      {
        "name": "Path",
        "args": { "pattern": "/api/order/**" }
      }
    ],
    "filters": [
      {
        "name": "StripPrefix",
        "args": { "parts": "1" }
      }
    ],
    "uri": "lb://order-service"
  },
  {
    "id": "user-service",
    "predicates": [
      {
        "name": "Path",
        "args": { "pattern": "/api/user/**" }
      }
    ],
    "uri": "lb://user-service"
  }
]

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true                    # 开启自动路由
          lower-case-service-id: true      # 服务名转小写
          filters:
            - RewritePath=/service/(?<segment>.*), /$\{segment}

@Component
@Order(-100)  // 高优先级，最先执行
public class JwtAuthGlobalFilter implements GlobalFilter {
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();
        
        // 1. 白名单放行
        if (isWhiteList(path)) {
            return chain.filter(exchange);
        }
        
        // 2. 获取 Token
        String token = extractToken(request);
        if (StringUtils.isEmpty(token)) {
            return unauthorized(exchange);
        }
        
        // 3. 验证 Token
        try {
            Claims claims = tokenProvider.parseToken(token);
            
            // 4. 将用户信息注入请求头，传给下游
            ServerHttpRequest mutatedRequest = request.mutate()
                .header("X-User-Id", claims.getSubject())
                .header("X-User-Role", claims.get("role", String.class))
                .build();
            
            return chain.filter(exchange.mutate().request(mutatedRequest).build());
        } catch (JwtException e) {
            return unauthorized(exchange);
        }
    }
    
    private String extractToken(ServerHttpRequest request) {
        String bearerToken = request.getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
    
    private Mono<Void> unauthorized(ServerWebExchange exchange) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        
        String body = "{\"code\":401,\"message\":\"Unauthorized\"}";
        DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
        return response.writeWith(Mono.just(buffer));
    }
}

spring:
  cloud:
    gateway:
      routes:
        # 90% 流量走 v1
        - id: order-service-v1
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
            - Weight=order, 9
          metadata:
            version: v1
        # 10% 流量走 v2
        - id: order-service-v2
          uri: lb://order-service-v2
          predicates:
            - Path=/api/order/**
            - Weight=order, 1
          metadata:
            version: v2

public class WeightRoutePredicateFactory 
    extends AbstractRoutePredicateFactory<WeightConfig> {
    
    @Override
    public Predicate<ServerWebExchange> apply(WeightConfig config) {
        return exchange -> {
            // 获取权重计算结果
            Map<String, String> weights = exchange.getAttribute(WEIGHT_ATTR);
            String routeId = exchange.getAttribute(GATEWAY_PREDICATE_MATCHED_PATH_ATTR);
            
            // 按权重随机选择
            String chosenRoute = weights.get(config.getGroup());
            return config.getRouteId().equals(chosenRoute);
        };
    }
}

spring:
  cloud:
    gateway:
      routes:
        # 带 X-Canary: true 的请求走 v2
        - id: order-service-canary
          uri: lb://order-service-v2
          predicates:
            - Path=/api/order/**
            - Header=X-Canary, true
        # 默认走 v1
        - id: order-service-default
          uri: lb://order-service
          predicates:
            - Path=/api/order/**

@Component
public class CanaryGlobalFilter implements GlobalFilter, Ordered {
    @Autowired
    private CanaryService canaryService;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String userId = exchange.getRequest().getHeaders().getFirst("X-User-Id");
        
        if (canaryService.isCanaryUser(userId)) {
            // 将请求路由到 canary 版本
            ServerHttpRequest request = exchange.getRequest().mutate()
                .header(GATEWAY_CANARY_HEADER, "true")
                .build();
            return chain.filter(exchange.mutate().request(request).build());
        }
        
        return chain.filter(exchange);
    }
    
    @Override
    public int getOrder() {
        return ROUTE_TO_URL_FILTER_ORDER - 1;  // 在负载均衡之前执行
    }
}

spring:
  cloud:
    gateway:
      httpclient:
        connect-timeout: 2000      # 连接超时 2s
        response-timeout: 5s       # 响应超时 5s
        pool:
          type: elastic            # 弹性连接池
          max-connections: 1000    # 最大连接数
          max-idle-time: 10s       # 空闲连接回收
        wiretap: false             # 关闭抓包（生产关）

spring:
  cloud:
    gateway:
      httpserver:
        wiretap: false
      httpclient:
        wiretap: false

@Component
public class CacheGatewayFilterFactory 
    extends AbstractGatewayFilterFactory<CacheGatewayFilterFactory.Config> {
    
    private final Cache<String, CachedResponse> cache = Caffeine.newBuilder()
        .expireAfterWrite(Duration.ofSeconds(30))
        .maximumSize(10000)
        .build();
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            String cacheKey = generateKey(exchange);
            CachedResponse cached = cache.getIfPresent(cacheKey);
            
            if (cached != null && !cached.isExpired()) {
                return writeCachedResponse(exchange, cached);
            }
            
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // 缓存响应（实际实现需要拦截响应体）
                cache.put(cacheKey, cacheResponse(exchange));
            }));
        };
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - StripPrefix=1
            - AddRequestHeader=X-Request-From, Gateway
            - name: Retry
              args:
                retries: 2
                statuses: SERVICE_UNAVAILABLE
                methods: GET
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
      # 全局跨域配置
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "https://example.com"
            allowedMethods: "*"
            allowedHeaders: "*"
            allowCredentials: true
      # 全局默认 Filter
      default-filters:
        - AddResponseHeader=X-Gateway-Version, 1.0.0

    nacos:
      discovery:
        server-addr: nacos-server:8848
      config:
        server-addr: nacos-server:8848
        file-extension: yaml

# Sentinel 限流规则（也可放 Nacos Config）
sentinel:
  transport:
    dashboard: localhost:8080
  datasource:
    gateway-flow:
      nacos:
        server-addr: nacos-server:8848
        dataId: gateway-flow-rules
        groupId: SENTINEL_GROUP
        rule-type: gw-flow

@Component
public class SignGatewayFilterFactory 
    extends AbstractGatewayFilterFactory<SignGatewayFilterFactory.Config> {
    
    public SignGatewayFilterFactory() {
        super(Config.class);
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            
            // 1. 获取签名参数
            String sign = request.getHeaders().getFirst("X-Sign");
            String timestamp = request.getHeaders().getFirst("X-Timestamp");
            String nonce = request.getHeaders().getFirst("X-Nonce");
            
            // 2. 验证时间戳（防重放，允许 5 分钟误差）
            long ts = Long.parseLong(timestamp);
            if (Math.abs(System.currentTimeMillis() - ts) > 5 * 60 * 1000) {
                return reject(exchange, "Timestamp expired");
            }
            
            // 3. 验证签名
            String serverSign = generateSign(request, timestamp, nonce, config.getSecret());
            if (!serverSign.equals(sign)) {
                return reject(exchange, "Invalid sign");
            }
            
            return chain.filter(exchange);
        };
    }
    
    private String generateSign(ServerHttpRequest request, String timestamp, 
                                 String nonce, String secret) {
        String data = timestamp + nonce + secret;
        return DigestUtils.md5DigestAsHex(data.getBytes());
    }
    
    @Data
    public static class Config {
        private String secret;
    }
}

filters:
  - name: Sign
    args:
      secret: "your-secret-key"

@Component
public class DynamicRouteService implements ApplicationEventPublisherAware {
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;
    @Autowired
    private RouteDefinitionLocator routeDefinitionLocator;
    
    private ApplicationEventPublisher publisher;
    
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    
    // 添加路由
    public void addRoute(RouteDefinition definition) {
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        publisher.publishEvent(new RefreshRoutesEvent(this));
    }
    
    // 删除路由
    public void deleteRoute(String routeId) {
        routeDefinitionWriter.delete(Mono.just(routeId)).subscribe();
        publisher.publishEvent(new RefreshRoutesEvent(this));
    }
    
    // 更新路由
    public void updateRoute(RouteDefinition definition) {
        routeDefinitionWriter.delete(Mono.just(definition.getId()))
            .then(routeDefinitionWriter.save(Mono.just(definition)))
            .subscribe();
        publisher.publishEvent(new RefreshRoutesEvent(this));
    }
    
    // 获取所有路由
    public Flux<RouteDefinition> getRoutes() {
        return routeDefinitionLocator.getRouteDefinitions();
    }
}

// REST API 管理路由
@RestController
@RequestMapping("/admin/routes")
public class RouteAdminController {
    @Autowired
    private DynamicRouteService dynamicRouteService;
    
    @PostMapping
    public Mono<Void> add(@RequestBody RouteDefinition definition) {
        dynamicRouteService.addRoute(definition);
        return Mono.empty();
    }
    
    @DeleteMapping("/{id}")
    public Mono<Void> delete(@PathVariable String id) {
        dynamicRouteService.deleteRoute(id);
        return Mono.empty();
    }
    
    @GetMapping
    public Flux<RouteDefinition> list() {
        return dynamicRouteService.getRoutes();
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - name: CircuitBreaker
              args:
                name: orderCircuitBreaker
                fallbackUri: forward:/fallback/order

@RestController
public class FallbackController {
    @RequestMapping("/fallback/order")
    public ResponseEntity<?> orderFallback(ServerWebExchange exchange) {
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body("{\"code\":503,\"message\":\"服务暂不可用，请稍后再试\"}");
    }
}

resilience4j:
  circuitbreaker:
    configs:
      default:
        slidingWindowSize: 10          # 统计窗口 10 次请求
        failureRateThreshold: 50       # 失败率 50% 熔断
        waitDurationInOpenState: 10s   # 熔断后等待 10 秒进入半开
        permittedNumberOfCallsInHalfOpenState: 3  # 半开允许 3 个探测请求
    instances:
      orderCircuitBreaker:
        baseConfig: default

用户 → CDN → Nginx（边缘）→ Spring Cloud Gateway（业务）→ 微服务

// 错误：在 GatewayFilter 中阻塞
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    String result = restTemplate.getForObject("http://auth/check", String.class);  // 阻塞！
    // ...
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    return webClient.get()
        .uri("http://auth/check")
        .retrieve()
        .bodyToMono(String.class)
        .flatMap(result -> {
            // 异步处理结果
            return chain.filter(exchange);
        });
}

// 错误：多次读取请求体
exchange.getRequest().getBody().subscribe(dataBuffer -> {
    // 第一次读取
});
exchange.getRequest().getBody().subscribe(dataBuffer -> {
    // 第二次读取为空！
});

// 正确：通过缓存读取
Object cachedBody = exchange.getAttribute(CACHED_REQUEST_BODY_ATTR);

// 错误：WebFlux 中 ThreadLocal 不可靠
String userId = RequestContext.getCurrentUserId();  // 可能为 null

// 写入
exchange.getAttributes().put("userId", userId);

// 或使用 Reactor Context
Mono.just(data)
    .subscriberContext(Context.of("userId", userId));

spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 50MB

// Gateway 层不做缓存，直接流式转发
return chain.filter(exchange.mutate()
    .request(exchange.getRequest().mutate()
        .header("Transfer-Encoding", "chunked")
        .build())
    .build());

spring:
  cloud:
    gateway:
      routes:
        - id: websocket-route
          uri: ws://websocket-service:8080  # 注意是 ws:// 不是 lb://
          predicates:
            - Path=/ws/**