// 1. 引入依賴（pom.xml）
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
// 2. 配置文件（application.yml）
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
// 3. 啟動類
@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

// 集成Nacos注冊中心
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
// 配置Nacos
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true  # 開啟服務(wù)發(fā)現(xiàn)
          lower-case-service-id: true

// 動態(tài)路由配置
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("order-service", r -> r.path("/api/order/**")
            .filters(f -> f.stripPrefix(1))
            .uri("lb://order-service"))
        .build();
}

// 多條件組合斷言
spring:
  cloud:
    gateway:
      routes:
        - id: complex-route
          uri: lb://service
          predicates:
            - Path=/api/**
            - Method=GET
            - Header=X-Request-Id, \d+
            - Query=token, \w+
            - After=2024-01-01T00:00:00+08:00

// 自定義全局過濾器
@Component
public class AuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (token == null || !validateToken(token)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return -100; // 優(yōu)先級
    }
}

// 自動集成Ribbon/LoadBalancer
spring:
  cloud:
    gateway:
      routes:
        - id: service-route
          uri: lb://service-name  # lb://前綴觸發(fā)負載均衡

// 基于Redis的分布式限流
spring:
  cloud:
    gateway:
      routes:
        - id: rate-limit-route
          uri: lb://service
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10  # 令牌桶填充速率
                redis-rate-limiter.burstCapacity: 20  # 令牌桶容量
                key-resolver: "#{@userKeyResolver}"   # 自定義key解析器

@Bean
KeyResolver userKeyResolver() {
    return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("userId"));
}

// 集成Hystrix/Sentinel
spring:
  cloud:
    gateway:
      routes:
        - id: circuit-breaker-route
          uri: lb://service
          filters:
            - name: Hystrix
              args:
                name: fallbackCommand
                fallbackUri: forward:/fallback

// 全局CORS配置
@Configuration
public class CorsConfig {
    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("*");
        config.addAllowedMethod("*");
        config.addAllowedHeader("*");
        config.setAllowCredentials(true);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

// 綜合應(yīng)用：API網(wǎng)關(guān)的完整配置
spring:
  cloud:
    gateway:
      # 全局過濾器配置
      default-filters:
        - AddResponseHeader=X-Response-Default, Default-Value
      routes:
        # 用戶服務(wù)路由
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200
        # 訂單服務(wù)路由（帶認證）
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - StripPrefix=1
            - name: Hystrix
              args:
                name: orderFallback
                fallbackUri: forward:/order/fallback
        # 靜態(tài)資源路由
        - id: static-resources
          uri: http://static.example.com
          predicates:
            - Path=/static/**

// 1. DispatcherHandler - 請求入口分發(fā)器
public class DispatcherHandler implements WebHandler {
    private final Map<String, HandlerMapping> handlerMappings;
    @Override
    public Mono<Void> handle(ServerWebExchange exchange) {
        // 遍歷所有HandlerMapping，找到匹配的處理器
        return handlerMappings.values()
            .stream()
            .filter(mapping -> mapping.matches(exchange))
            .findFirst()
            .map(mapping -> mapping.getHandler(exchange))
            .orElse(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
            .flatMap(handler -> handler.handle(exchange));
    }
}
// 2. RoutePredicateHandlerMapping - 路由匹配器
public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
    @Override
    protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
        // 1. 獲取所有路由
        Flux<Route> routes = routeLocator.getRoutes();
        // 2. 根據(jù)Predicate匹配路由
        return routes.filter(route -> {
            List<PredicateDefinition> predicates = route.getPredicates();
            return predicates.stream()
                .allMatch(predicate -> predicate.apply(exchange));
        })
        .next() // 返回第一個匹配的路由
        .map(route -> {
            exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
            return webHandler; // 返回FilteringWebHandler
        });
    }
}
// 3. FilteringWebHandler - 過濾器鏈處理器
public class FilteringWebHandler implements WebHandler {
    @Override
    public Mono<Void> handle(ServerWebExchange exchange) {
        Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
        // 1. 獲取路由的過濾器
        List<GatewayFilter> routeFilters = route.getFilters();
        // 2. 獲取全局過濾器
        List<GlobalFilter> globalFilters = globalFilters();
        // 3. 合并并排序
        List<GatewayFilter> combined = combineFilters(routeFilters, globalFilters);
        // 4. 構(gòu)建過濾器鏈
        GatewayFilterChain chain = new DefaultGatewayFilterChain(combined);
        // 5. 執(zhí)行過濾器鏈
        return chain.filter(exchange);
    }
}
// 4. DefaultGatewayFilterChain - 責(zé)任鏈模式
private static class DefaultGatewayFilterChain implements GatewayFilterChain {
    private final int index;
    private final List<GatewayFilter> filters;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
        if (index < filters.size()) {
            // 遞歸調(diào)用下一個過濾器
            GatewayFilter filter = filters.get(index);
            return filter.filter(exchange, this);
        } else {
            // 所有過濾器執(zhí)行完畢，轉(zhuǎn)發(fā)請求
            return ((NettyRoutingFilter) filters.get(filters.size() - 1))
                .route(exchange);
        }
    }
}

// 傳統(tǒng)阻塞IO vs 響應(yīng)式非阻塞IO
// 傳統(tǒng)Servlet模型（阻塞）
@WebServlet("/api")
public class BlockingServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // 每個請求占用一個線程，直到IO完成
        String result = database.query(); // 阻塞等待
        resp.getWriter().write(result);
    }
}
// 問題：1000個并發(fā)請求 = 1000個線程 = 高內(nèi)存消耗
// Gateway響應(yīng)式模型（非阻塞）
@GetMapping("/api")
public Mono<String> reactiveApi() {
    // 線程不等待，注冊回調(diào)，IO完成后觸發(fā)
    return database.queryAsync() // 返回Mono
        .map(result -> process(result));
}
// 優(yōu)勢：少量線程處理大量并發(fā)請求

// Netty的內(nèi)存池化技術(shù)（PooledByteBufAllocator）
// 傳統(tǒng)方式：每次分配新內(nèi)存
byte[] buffer1 = new byte[1024]; // 分配
// 使用...
buffer1 = null; // 釋放，等待GC
// Netty內(nèi)存池：復(fù)用內(nèi)存塊
PooledByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;
ByteBuf buffer = allocator.buffer(1024); // 從池中獲取
// 使用...
buffer.release(); // 歸還到池中，可復(fù)用
// 優(yōu)勢：
// 1. 減少內(nèi)存分配/釋放開銷
// 2. 降低GC壓力
// 3. 避免內(nèi)存碎片

// HTTP連接池配置
spring:
  cloud:
    gateway:
      httpclient:
        pool:
          type: ELASTIC  # 彈性連接池
          max-connections: 1000  # 最大連接數(shù)
          acquire-timeout: 45000 # 獲取連接超時
// 連接復(fù)用機制
┌─────────────────────────────────────────────────────┐
│  Connection Pool (連接池)                            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐             │
│  │ Conn1   │  │ Conn2   │  │ Conn3   │             │
│  │ (復(fù)用)   │  │ (復(fù)用)   │  │ (復(fù)用)   │             │
│  └─────────┘  └─────────┘  └─────────┘             │
└─────────────────────────────────────────────────────┘
        ↓           ↓           ↓
    Service1    Service2    Service3
// 優(yōu)勢：
// 1. 避免頻繁建立/斷開TCP連接
// 2. 減少TCP握手開銷
// 3. 提高請求響應(yīng)速度

// 路由匹配流程
public class RoutePredicateHandlerMapping {
    public Mono<Route> getRoute(ServerWebExchange exchange) {
        return routeLocator.getRoutes()
            .filter(route -> {
                // 1. Path匹配（AntPathMatcher）
                if (route.getPath() != null) {
                    AntPathMatcher matcher = new AntPathMatcher();
                    if (!matcher.match(route.getPath(), exchange.getRequest().getPath().value())) {
                        return false;
                    }
                }
                // 2. Method匹配
                if (route.getMethod() != null) {
                    if (!route.getMethod().equals(exchange.getRequest().getMethod())) {
                        return false;
                    }
                }
                // 3. Header匹配
                if (route.getHeaders() != null) {
                    for (Map.Entry<String, String> header : route.getHeaders().entrySet()) {
                        String value = exchange.getRequest().getHeaders().getFirst(header.getKey());
                        if (value == null || !value.matches(header.getValue())) {
                            return false;
                        }
                    }
                }
                // 4. Query匹配
                // 5. Cookie匹配
                // 6. 其他Predicate...
                return true;
            })
            .next(); // 返回第一個匹配的路由
    }
}
// 性能優(yōu)化：路由緩存
private final Map<String, Route> routeCache = new ConcurrentHashMap<>();
public Mono<Route> getCachedRoute(String path) {
    return Mono.justOrEmpty(routeCache.get(path))
        .switchIfEmpty(getRouteFromLocator(path)
            .doOnNext(route -> routeCache.put(path, route)));
}

// LoadBalancerClientFilter - 負載均衡過濾器
public class LoadBalancerClientFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
        if (url != null && "lb".equals(url.getScheme())) {
            // 1. 解析服務(wù)名
            String serviceId = url.getHost();
            // 2. 獲取服務(wù)實例列表
            ServiceInstance instance = loadBalancer.choose(serviceId);
            // 3. 構(gòu)建實際請求URL
            URI uri = reconstructURI(instance, url);
            exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, uri);
        }
        return chain.filter(exchange);
    }
}
// 負載均衡算法實現(xiàn)
public class RoundRobinLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private final AtomicInteger position = new AtomicInteger();
    @Override
    public Mono<ServiceInstance> choose(Request request) {
        List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
        if (instances.isEmpty()) {
            return Mono.empty();
        }
        // 輪詢算法
        int pos = Math.abs(position.incrementAndGet() % instances.size());
        return Mono.just(instances.get(pos));
    }
}
// 權(quán)重負載均衡
public class WeightedLoadBalancer {
    public ServiceInstance chooseWeighted(List<ServiceInstance> instances) {
        // 計算總權(quán)重
        int totalWeight = instances.stream()
            .mapToInt(i -> i.getMetadata().getOrDefault("weight", "1"))
            .mapToInt(Integer::parseInt)
            .sum();
        // 隨機選擇
        int random = ThreadLocalRandom.current().nextInt(totalWeight);
        // 根據(jù)權(quán)重分配
        int current = 0;
        for (ServiceInstance instance : instances) {
            current += Integer.parseInt(instance.getMetadata().get("weight"));
            if (random < current) {
                return instance;
            }
        }
        return instances.get(0);
    }
}

// 基于Nacos的動態(tài)路由
@Component
public class NacosRouteDefinitionRepository implements RouteDefinitionRepository {
    @Autowired
    private ConfigService configService;
    // 監(jiān)聽Nacos配置變化
    @PostConstruct
    public void init() throws NacosException {
        configService.addListener("gateway-routes", "DEFAULT_GROUP", 
            new Listener() {
                @Override
                public void receiveConfigInfo(String configInfo) {
                    // 解析配置
                    List<RouteDefinition> routes = parseRoutes(configInfo);
                    // 更新路由
                    routes.forEach(route -> {
                        routeDefinitionWriter.save(Mono.just(route)).subscribe();
                    });
                }
            });
    }
    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        // 從Nacos獲取路由配置
        String config = configService.getConfig("gateway-routes", "DEFAULT_GROUP", 5000);
        List<RouteDefinition> routes = parseRoutes(config);
        return Flux.fromIterable(routes);
    }
}
// 路由熱更新流程
┌─────────────────────────────────────────────────────┐
│  1. Nacos配置變更                                     │
│     ↓                                                │
│  2. 監(jiān)聽器收到通知                                    │
│     ↓                                                │
│  3. 解析新的路由配置                                  │
│     ↓                                                │
│  4. 調(diào)用RouteDefinitionWriter保存                     │
│     ↓                                                │
│  5. CachingRouteLocator清除緩存                       │
│     ↓                                                │
│  6. 新路由生效（無需重啟）                            │
└─────────────────────────────────────────────────────┘