#服务网关 Gateway 核心原理

// Route（路由）：包含目的地地址和过滤器链
public class Route implements Ordered {
    private String id;
    private URI uri;                    // 目标地址
    private int order;                  // 优先级
    private List<GatewayFilter> filters; // 过滤器链
    private AsyncPredicate<ServerWebExchange> predicate;  // 断言条件
}

// Predicate（断言）：判断请求是否匹配该路由
// 常见的 Predicate 类型：
// - Path=/user/**
// - Method=GET
// - Header=X-Request-Id, \d+
// - Query=foo, bar
// - Cookie=session, abc
// - After/Before/Between=某个时间点

// GatewayFilter（过滤器）：拦截并处理请求/响应
// 分为：
// - GatewayFilter：局部过滤器，只作用于当前路由
// - GlobalFilter：全局过滤器，作用于所有路由

// GatewayAutoConfiguration.java
// Gateway 的核心配置类

// 1. DispatcherHandler：请求分发器（类似 Spring MVC 的 DispatcherServlet）
public class DispatcherHandler implements WebHandler, ApplicationEventPublisherAware {
    private Map<String, HandlerMapping> handlerMappings;
    private Map<String, HandlerAdapter> handlerAdapters;
    private Map<String, HandlerResultHandler> resultHandlers;

    @Override
    public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
        // 匹配路由
        return handlerMappings
            .get(handlerMapping ->
                handlerMapping.getHandler(exchange)  // 根据断言匹配路由
            )
            // 构建过滤器链
            .flatMap(handler -> new FilteringWebHandler(handler).handle(exchange))
            // 执行过滤器和路由
            .then();
    }
}

// 2. RoutePredicateHandlerMapping：路由映射器
// 根据请求属性（path、method、header等）匹配路由
public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
    @Override
    protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
        // 从请求中获取路径
        String path = exchange.getRequest().getPath().value();
        // 遍历所有路由，找到第一个匹配的
        return flux
            .flatMap(route -> matchRoute(route, path, exchange))
            .next();
    }
}

// 3. FilteringWebHandler：过滤器执行器
public class FilteringWebHandler implements WebHandler {
    // 将全局过滤器和路由局部过滤器合并成一个链
    public FilteringWebHandler(Route route) {
        this.route = route;
        // 合并 GlobalFilter 和 GatewayFilter
        this.globalFilters = loadFilters();
        this.gatewayFilters = route.getFilters();
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange) {
        // 按优先级排序所有过滤器
        List<GatewayFilter> allFilters = new ArrayList<>();
        allFilters.addAll(this.globalFilters);
        allFilters.addAll(this.gatewayFilters);

        // 按 @Order 排序（数字越小优先级越高）
        allFilters.sort(Comparator.comparingInt(GatewayFilter::getOrder));

        // 构建过滤器链，执行 Pre Filter
        return new GatewayFilterChain(allFilters).filter(exchange);
    }
}

// 4. 过滤器链：类似责任链模式
public class DefaultGatewayFilterChain implements GatewayFilterChain {
    private final List<GatewayFilter> filters;
    private final int index;

    public Mono<Void> filter(ServerWebExchange exchange) {
        if (index >= filters.size()) {
            // 所有过滤器执行完毕，发送代理请求
            return handleNow(exchange);
        }
        // 执行当前过滤器
        GatewayFilter filter = filters.get(index);
        return filter.filter(exchange, new DefaultGatewayFilterChain(filters, index + 1));
    }
}

// 常见内置过滤器的默认优先级（数字越小越先执行）

// 第一梯队：系统级过滤器
NettyRoutingFilter = OrderedHighest = Integer.MIN_VALUE   // Netty 路由
NettyWriteResponseFilter = OrderedHighest + 1              // 写响应
ForwardRoutingFilter = OrderedHighest + 1                 // 转发

// 第二梯队：全局日志/监控
AdaptCachedBodyGlobalFilter = -1                          // 缓存请求体
RemoveCachedBodyFilter = 0                                // 移除缓存体

// 第三梯队：业务过滤器
RouteToRequestUrlFilter = 1                                // 路由到 URL
LoadBalancerClientFilter = 10101                          // 负载均衡客户端

// 第四梯队：局部过滤器
StripPrefix = 1                                           // 路径去除前缀
AddRequestHeader = 0                                       // 添加请求头

@Component
@Slf4j
public class AuthGlobalFilter implements GlobalFilter {
    @Autowired
    private JwtUtil jwtUtil;

    // 排除路径：登录、注册等不需要鉴权
    private final List<String> excludePaths = Arrays.asList(
        "/auth/login",
        "/auth/register",
        "/health"
    );

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getPath().value();

        // 跳过不需要鉴权的路径
        if (isExcludePath(path)) {
            return chain.filter(exchange);
        }

        // 获取 Token
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (token == null || !token.startsWith("Bearer ")) {
            return unauthorized(exchange, "Missing or invalid token");
        }

        // 验证 Token
        try {
            Claims claims = jwtUtil.parseToken(token.substring(7));
            // 将用户信息注入到请求属性中，传递给后端服务
            exchange.getAttributes().put("userId", claims.getSubject());
            exchange.getAttributes().put("roles", claims.get("roles"));
        } catch (Exception e) {
            return unauthorized(exchange, "Token validation failed");
        }

        // 继续过滤器链
        return chain.filter(exchange);
    }

    private boolean isExcludePath(String path) {
        return excludePaths.stream().anyMatch(path::startsWith);
    }

    private Mono<Void> unauthorized(ServerWebExchange exchange, String message) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        return response.setComplete();
    }
}

@Configuration
public class RateLimiterConfig {
    // 基于路径限流
    @Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getPath().value()
        );
    }

    // 基于用户 IP 限流
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            Objects.requireNonNull(
                exchange.getRequest().getRemoteAddress()
            ).getAddress().getHostAddress()
        );
    }

    // 基于用户 ID 限流（需要先鉴权）
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.justOrEmpty(
            exchange.getAttribute("userId")
        ).defaultIfEmpty("anonymous");
    }
}

@Autowired
private RouteDefinitionWriter routeDefinitionWriter;

// 动态添加路由
public Mono<Void> addRoute(Mono<RouteDefinition> route) {
    return route.flatMap(routeDefinition -> {
        routeDefinitionWriter.save(Mono.just(
            RouteDefinition.of(
                routeDefinition.getId(),
                routeDefinition.getUri(),
                routeDefinition.getOrder(),
                routeDefinition.getPredicates(),
                routeDefinition.getFilters()
            )
        )).then();
    });
}