#Gateway 过滤器与路由断言

// FilteringWebHandler.java - 过滤器执行的核心类
public class FilteringWebHandler implements WebHandler {
    private final Route route;
    private final List<GatewayFilter> globalFilters;

    @Override
    public Mono<Void> handle(ServerWebExchange exchange) {
        // 1. 合并全局过滤器和路由局部过滤器
        List<GatewayFilter> allFilters = new ArrayList<>();
        allFilters.addAll(this.globalFilters);   // GlobalFilter
        allFilters.addAll(route.getFilters());   // GatewayFilter

        // 2. 按优先级排序（Order 越小越先执行）
        allFilters.sort(Comparator.comparingInt(GatewayFilter::getOrder));

        // 3. 构建过滤器链
        return new DefaultGatewayFilterChain(allFilters, 0).filter(exchange);
    }
}

// DefaultGatewayFilterChain.java - 责任链实现
public class DefaultGatewayFilterChain implements GatewayFilterChain {
    private final List<GatewayFilter> filters;
    private final int index;

    public Mono<Void> filter(ServerWebExchange exchange) {
        if (this.index >= this.filters.size()) {
            // 所有过滤器执行完毕，发送请求到后端
            return handleNow(exchange);
        }

        // 执行当前索引的过滤器
        GatewayFilter filter = this.filters.get(this.index);

        // 递归调用下一个过滤器
        return filter.filter(exchange,
            new DefaultGatewayFilterChain(this.filters, this.index + 1));
    }
}

// Gateway 过滤器的 Order 来源有两种：

// 方式一：实现 Ordered 接口
@Component
public class MyFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 过滤器逻辑
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -100;  // 数字越小，优先级越高，越先执行
    }
}

// 方式二：使用 @Order 注解
@Component
@Order(-100)
public class AnotherFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange);
    }
}

// 常见内置过滤器的优先级
/*
 * NettyRoutingFilter              Integer.MIN_VALUE  最先执行
 * NettyWriteResponseFilter        Integer.MIN_VALUE + 1
 * ForwardRoutingFilter            Integer.MIN_VALUE + 1
 * RouteToRequestUrlFilter        10000
 * LoadBalancerClientFilter       10101
 * WebsocketRoutingFilter         Integer.MAX_VALUE  最后执行
 */

// 自定义全局过滤器：记录请求耗时
@Component
@Slf4j
public class RequestTimeFilter implements GlobalFilter, Ordered {

    private static final String START_TIME = "startTime";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1. Pre 阶段：记录开始时间
        exchange.getAttributes().put(START_TIME, System.currentTimeMillis());

        // 2. 继续执行过滤器链
        return chain.filter(exchange)
            // 3. Post 阶段：计算并记录耗时
            .then(Mono.fromRunnable(() -> {
                Long startTime = exchange.getAttribute(START_TIME);
                if (startTime != null) {
                    long duration = System.currentTimeMillis() - startTime;
                    String path = exchange.getRequest().getPath().value();
                    log.info("请求路径: {}, 耗时: {}ms", path, duration);
                }
            }));
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;  // 最高优先级，最先执行
    }
}

// 1. 定义自定义过滤器工厂
@Component
public class MyGatewayFilterFactory
    extends AbstractGatewayFilterFactory<MyGatewayFilterFactory.Config> {

    public static class Config {
        private String prefix;
        private boolean enabled = true;

        public String getPrefix() { return prefix; }
        public void setPrefix(String prefix) { this.prefix = prefix; }
        public boolean isEnabled() { return enabled; }
        public void setEnabled(boolean enabled) { this.enabled = enabled; }
    }

    public MyGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            if (!config.isEnabled()) {
                return chain.filter(exchange);
            }

            String prefix = config.getPrefix() != null
                ? config.getPrefix()
                : "default";

            // 添加带前缀的 Header
            ServerHttpRequest request = exchange.getRequest().mutate()
                .header("X-Request-Prefix", prefix)
                .build();

            return chain.filter(
                exchange.mutate().request(request).build()
            );
        };
    }
}

// 自定义断言工厂
@Component
public class UserIdHeaderRoutePredicateFactory
    extends AbstractRoutePredicateFactory<UserIdHeaderRoutePredicateFactory.Config> {

    public static class Config {
        private String headerName = "X-User-Id";

        public String getHeaderName() { return headerName; }
        public void setHeaderName(String headerName) {
            this.headerName = headerName;
        }
    }

    public UserIdHeaderRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            String userId = exchange.getRequest()
                .getHeaders()
                .getFirst(config.getHeaderName());
            // 判断 userId 是否存在且为数字
            return userId != null && userId.matches("\\d+");
        };
    }
}

// RouteDefinitionWriter.java - 动态路由接口
public interface RouteDefinitionWriter {
    // 保存路由定义
    Mono<Void> save(Mono<RouteDefinition> route);

    // 删除路由
    Mono<Void> delete(Mono<String> routeId);

    // 更新路由
    default Mono<Void> update(Mono<RouteDefinition> route) {
        return save(route);
    }
}

// 动态添加路由
@RestController
public class DynamicRouteController {
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    @PostMapping("/routes")
    public Mono<ResponseEntity<Void>> addRoute(@RequestBody RouteDefinition route) {
        return routeDefinitionWriter.save(Mono.just(route))
            .then(Mono.just(ResponseEntity.ok().<Void>build()));
    }

    @DeleteMapping("/routes/{id}")
    public Mono<ResponseEntity<Void>> deleteRoute(@PathVariable String id) {
        return routeDefinitionWriter.delete(Mono.just(id))
            .then(Mono.just(ResponseEntity.noContent().build()));
    }
}

// ❌ 错误：限流 Filter 在鉴权 Filter 之前执行
// 导致未登录用户也会被限流统计
public class RateLimitFilter implements GlobalFilter {
    @Override
    public int getOrder() {
        return 0;  // 鉴权是 -100，应该比它先执行（数字更小）
    }
}

public class AuthFilter implements GlobalFilter {
    @Override
    public int getOrder() {
        return -100;  // 鉴权应该最先执行
    }
}

// ✅ 正确：鉴权 Filter 的 Order 更小（优先级更高）
// 执行顺序：AuthFilter(-100) -> RateLimitFilter(0)

// ❌ 错误：没有正确使用 then()，导致 Post 阶段不执行
public class MyFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange)
            .doOnSuccess(aVoid -> {
                // 注意：这个 doOnSuccess 不会在 Post 过滤器中执行
                // 因为它没有包装成 filter 链的一部分
                System.out.println("执行了");
            });
    }
}

// ✅ 正确：使用 then() 将 Post 逻辑串联到过滤器链
public class MyFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Pre 逻辑
        System.out.println("Pre 阶段");

        return chain.filter(exchange)
            // Post 逻辑：then() 接收一个 Mono，在请求处理完成后执行
            .then(Mono.fromRunnable(() -> {
                System.out.println("Post 阶段");
            }));
    }
}