@Component
public class LoggingGatewayFilterFactory extends 
        AbstractGatewayFilterFactory<LoggingGatewayFilterFactory.Config> {
    
    public LoggingGatewayFilterFactory() {
        super(Config.class);
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // PRE-обработка
            if (config.isLogRequest()) {
                logRequest(exchange, config);
            }
            
            long startTime = System.nanoTime();
            
            // POST-обработка через then()
            return chain.filter(exchange)
                .then(Mono.fromRunnable(() -> {
                    if (config.isLogResponse()) {
                        long duration = System.nanoTime() - startTime;
                        logResponse(exchange, config, duration);
                    }
                }));
        };
    }
    
    public static class Config {
        private boolean logRequest = true;
        private boolean logResponse = true;
        private LogLevel level = LogLevel.INFO;
        
        // Геттеры и сеттеры
    }
    
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("logRequest", "logResponse", "level");
    }
}

filters:
  - Logging=true,true,DEBUG

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TraceIdGlobalFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Генерация или извлечение TraceId
        String traceId = exchange.getRequest().getHeaders()
            .getFirst("X-Trace-Id");
        
        if (traceId == null || traceId.isEmpty()) {
            traceId = UUID.randomUUID().toString();
        }
        
        // Добавление в заголовки запроса
        ServerHttpRequest mutated = exchange.getRequest().mutate()
            .header("X-Trace-Id", traceId)
            .build();
        
        // Добавление в атрибуты для использования в других фильтрах
        exchange.getAttributes().put("traceId", traceId);
        
        return chain.filter(exchange.mutate().request(mutated).build());
    }
}

@Component
public class DynamicOrderFilter implements GlobalFilter, Ordered {
    
    private final Environment environment;
    private int order = 0;
    
    public DynamicOrderFilter(Environment environment) {
        this.environment = environment;
        // Динамическое определение порядка из конфигурации
        this.order = environment.getProperty("gateway.filter.order", 
            Integer.class, 0);
    }
    
    @Override
    public int getOrder() {
        return order;
    }
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Логика фильтра
        return chain.filter(exchange);
    }
}

@Component
public class ExternalValidationFilter implements GlobalFilter {
    
    private final WebClient webClient;
    private final CircuitBreaker circuitBreaker;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1. Извлечение данных для валидации
        String apiKey = exchange.getRequest().getHeaders()
            .getFirst("X-API-Key");
        
        if (apiKey == null) {
            return unauthorized(exchange);
        }
        
        // 2. Асинхронная валидация через внешний сервис
        return circuitBreaker.run(
            webClient.get()
                .uri("/validate?apiKey={key}", apiKey)
                .retrieve()
                .bodyToMono(ValidationResponse.class)
                .timeout(Duration.ofSeconds(5))
                .onErrorResume(e -> Mono.just(new ValidationResponse(false))),
            throwable -> Mono.just(new ValidationResponse(false))
        )
        .flatMap(validationResponse -> {
            // 3. Обработка результата валидации
            if (validationResponse.isValid()) {
                // Добавление информации о пользователе в заголовки
                ServerHttpRequest mutated = exchange.getRequest().mutate()
                    .header("X-User-Id", validationResponse.getUserId())
                    .header("X-User-Roles", 
                        String.join(",", validationResponse.getRoles()))
                    .build();
                
                return chain.filter(exchange.mutate().request(mutated).build());
            } else {
                return unauthorized(exchange);
            }
        });
    }
    
    private Mono<Void> unauthorized(ServerWebExchange exchange) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }
}

@Component
public class RequestBodyLoggingFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Только для определенных Content-Type
        MediaType contentType = exchange.getRequest().getHeaders().getContentType();
        if (contentType == null || !contentType.includes(MediaType.APPLICATION_JSON)) {
            return chain.filter(exchange);
        }
        
        // Ограничение размера для логирования
        final int maxBodySize = 1024 * 10; // 10KB
        
        return DataBufferUtils.join(exchange.getRequest().getBody(), maxBodySize)
            .defaultIfEmpty(EMPTY_BUFFER)
            .flatMap(dataBuffer -> {
                try {
                    // Чтение и логирование
                    byte[] bytes = new byte[Math.min(dataBuffer.readableByteCount(), maxBodySize)];
                    dataBuffer.read(bytes);
                    
                    String body = new String(bytes, StandardCharsets.UTF_8);
                    log.debug("Request body (first {} bytes): {}", bytes.length, body);
                    
                    // Восстановление тела
                    DataBuffer restoredBuffer = exchange.getResponse().bufferFactory()
                        .wrap(bytes);
                    
                    // Продолжение цепочки с восстановленным телом
                    ServerHttpRequest mutated = exchange.getRequest().mutate()
                        .body(Flux.just(restoredBuffer)
                            .concatWith(exchange.getRequest().getBody()
                                .skipUntil(buffer -> false))) // Пропускаем уже прочитанное
                        .build();
                    
                    return chain.filter(exchange.mutate().request(mutated).build());
                    
                } finally {
                    DataBufferUtils.release(dataBuffer);
                }
            });
    }
}