@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.cloud.gateway.server.webflux.enabled", matchIfMissing = true)
@EnableConfigurationProperties
@AutoConfigureBefore({ HttpHandlerAutoConfiguration.class, WebFluxAutoConfiguration.class })
@AutoConfigureAfter({ GatewayReactiveLoadBalancerClientAutoConfiguration.class,
        GatewayClassPathWarningAutoConfiguration.class })
@ConditionalOnClass(DispatcherHandler.class)
public class GatewayAutoConfiguration {
    // 核心 Bean 定義
}

# 可以通過配置控制是否啟用
spring:
  cloud:
    gateway:
      server:
        webflux:
          enabled: true  # 默認(rèn)啟用，可以設(shè)置為 false 禁用

@Override
protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
    // 1. 查找匹配的路由（異步操作）
    return lookupRoute(exchange)
        .map(route -> {
            // 2. 把路由信息存儲到 Exchange 的屬性中
            exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
            // 3. 返回 FilteringWebHandler 作為處理器
            return webHandler;
        });
}

// 假設(shè)有這些路由配置
routes = [
    { id: "user-service", path: "/api/users/**", uri: "http://user-service" },
    { id: "order-service", path: "/api/orders/**", uri: "http://order-service" }
]
// 請求：GET /api/users/123
// lookupRoute() 會：
// 1. 遍歷所有路由
// 2. 使用 AsyncPredicate 異步匹配
// 3. 找到匹配的路由：user-service
// 4. 返回 FilteringWebHandler

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    // 1. 從 Exchange 中獲取路由信息（路由匹配時設(shè)置的）
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    // 2. 獲取合并后的過濾器列表（全局過濾器 + 路由過濾器）
    List<GatewayFilter> combined = getCombinedFilters(route);
    // 3. 創(chuàng)建過濾器鏈并執(zhí)行
    return new DefaultGatewayFilterChain(combined).filter(exchange);
}

// 假設(shè)路由配置了這些過濾器
route.filters = [
    AddRequestHeaderFilter,
    RateLimitFilter,
    NettyRoutingFilter  // 最后一個，負(fù)責(zé)實(shí)際轉(zhuǎn)發(fā)請求
]
// FilteringWebHandler 會：
// 1. 合并全局過濾器和路由過濾器
// 2. 按 Order 排序
// 3. 創(chuàng)建過濾器鏈
// 4. 依次執(zhí)行過濾器

// 過濾器鏈的實(shí)現(xiàn)（責(zé)任鏈模式）
private static class DefaultGatewayFilterChain implements GatewayFilterChain {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
        return Mono.defer(() -> {
            if (this.index < filters.size()) {
                GatewayFilter filter = filters.get(this.index);
                // 創(chuàng)建下一個鏈節(jié)點(diǎn)
                DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
                // 執(zhí)行當(dāng)前過濾器，傳入下一個鏈節(jié)點(diǎn)
                return filter.filter(exchange, chain);
            }
            return Mono.empty();  // 所有過濾器執(zhí)行完畢
        });
    }
}

@Bean
@Primary
public RouteLocator cachedCompositeRouteLocator(List<RouteLocator> routeLocators) {
    // 1. 組合多個 RouteLocator
    CompositeRouteLocator composite = new CompositeRouteLocator(
        Flux.fromIterable(routeLocators)
    );
    // 2. 添加緩存（提高性能）
    return new CachingRouteLocator(composite);
}

// 可以有多個 RouteLocator
RouteLocator[] locators = [
    PropertiesRouteDefinitionLocator,      // 從配置文件讀取路由
    DiscoveryClientRouteDefinitionLocator, // 從服務(wù)發(fā)現(xiàn)讀取路由
    InMemoryRouteDefinitionRepository      // 從內(nèi)存（API）讀取路由
]
// CompositeRouteLocator 會合并所有路由
// 返回 Flux<Route>，包含所有路由

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8081

// 自動從 Eureka/Consul 等服務(wù)注冊中心發(fā)現(xiàn)服務(wù)
// 為每個服務(wù)自動創(chuàng)建路由

// 通過 API 動態(tài)添加/刪除路由
routeDefinitionRepository.save(routeDefinition);

客戶端 → DispatcherHandler → Gateway

// 獲取所有路由（返回 Flux<Route>，是響應(yīng)式的）
Flux<Route> routes = routeLocator.getRoutes();
// 實(shí)際的路由列表可能是：
// [
//   { id: "user-service", path: "/api/users/**", uri: "http://user-service" },
//   { id: "order-service", path: "/api/orders/**", uri: "http://order-service" }
// ]

// 異步匹配路由
return routes
    .filterWhen(route -> {
        // 使用 AsyncPredicate 異步匹配
        return route.getPredicate().test(exchange);
    })
    .next();  // 返回第一個匹配的路由

// 路由1：user-service
AsyncPredicate predicate1 = exchange -> {
    String path = exchange.getRequest().getPath().value();
    return Mono.just(path.startsWith("/api/users/"));  // 異步返回 true/false
};
// 路徑 "/api/users/123" 匹配 "/api/users/**" ?
// 路由2：order-service
AsyncPredicate predicate2 = exchange -> {
    String path = exchange.getRequest().getPath().value();
    return Mono.just(path.startsWith("/api/orders/"));  // 異步返回 false
};
// 路徑 "/api/users/123" 不匹配 "/api/orders/**" ?

// 匹配成功后
Route matchedRoute = ...;  // user-service 路由
// 存儲路由信息到 Exchange 的屬性中
exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, matchedRoute);
exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, matchedRoute.getUri());

// 返回 FilteringWebHandler
return Mono.just(webHandler);

# 配置文件
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://user-service:8081
          predicates:
            - Path=/api/users/**
            - Method=GET

Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
List<GatewayFilter> routeFilters = route.getFilters();
// 假設(shè)路由配置了這些過濾器：
// [AddRequestHeaderFilter, RateLimitFilter]

// 全局過濾器（應(yīng)用于所有路由）
List<GlobalFilter> globalFilters = [
    LoadBalancerClientFilter,      // Order: 10100
    NettyRoutingFilter,            // Order: Ordered.LOWEST_PRECEDENCE
    NettyWriteResponseFilter       // Order: Ordered.LOWEST_PRECEDENCE - 1
];
// 路由過濾器
List<GatewayFilter> routeFilters = [
    AddRequestHeaderFilter,         // Order: 1000
    RateLimitFilter                 // Order: -100
];
// 合并并排序
List<GatewayFilter> combined = [
    RateLimitFilter,                // -100 (最高優(yōu)先級)
    AddRequestHeaderFilter,         // 1000
    LoadBalancerClientFilter,       // 10100
    NettyRoutingFilter,             // LOWEST_PRECEDENCE
    NettyWriteResponseFilter        // LOWEST_PRECEDENCE - 1
];

// 創(chuàng)建過濾器鏈
DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(combined);
// 過濾器鏈的內(nèi)部實(shí)現(xiàn)
private static class DefaultGatewayFilterChain implements GatewayFilterChain {
    private final int index;  // 當(dāng)前執(zhí)行的過濾器索引
    private final List<GatewayFilter> filters;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
        return Mono.defer(() -> {
            if (this.index < filters.size()) {
                GatewayFilter filter = filters.get(this.index);
                // 創(chuàng)建下一個鏈節(jié)點(diǎn)
                DefaultGatewayFilterChain nextChain = 
                    new DefaultGatewayFilterChain(this, this.index + 1);
                // 執(zhí)行當(dāng)前過濾器，傳入下一個鏈節(jié)點(diǎn)
                return filter.filter(exchange, nextChain);
            }
            return Mono.empty();  // 所有過濾器執(zhí)行完畢
        });
    }
}

// 執(zhí)行流程（簡化版）
RateLimitFilter.filter(exchange, chain1)
  -> 檢查限流
  -> chain1.filter(exchange)  // 調(diào)用下一個過濾器
    -> AddRequestHeaderFilter.filter(exchange, chain2)
      -> 添加請求頭
      -> chain2.filter(exchange)  // 調(diào)用下一個過濾器
        -> LoadBalancerClientFilter.filter(exchange, chain3)
          -> 負(fù)載均衡選擇實(shí)例
          -> chain3.filter(exchange)
            -> NettyRoutingFilter.filter(exchange, chain4)
              -> 轉(zhuǎn)發(fā)請求到下游服務(wù)
              -> chain4.filter(exchange)
                -> NettyWriteResponseFilter.filter(exchange, chain5)
                  -> 寫入響應(yīng)
                  -> chain5.filter(exchange)
                    -> Mono.empty()  // 所有過濾器執(zhí)行完畢

// NettyRoutingFilter 的實(shí)現(xiàn)（簡化版）
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);
    // 使用 Reactor Netty HttpClient 發(fā)送請求（非阻塞）
    return httpClient.get()
        .uri(requestUrl)
        .send((req, nettyOutbound) -> nettyOutbound.send(request.getBody()))
        .responseConnection((res, connection) -> {
            // 設(shè)置響應(yīng)到 Exchange
            exchange.getAttributes().put(CLIENT_RESPONSE_ATTR, res);
            return Mono.just(res);
        })
        .then(chain.filter(exchange));  // 繼續(xù)執(zhí)行下一個過濾器
}