Шаблоны API Gateway и управление трафиком микросервисов

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("order_route", r -> r.path("/orders/**")
            .uri("lb://order-service"))
        .route("payment_route", r -> r.path("/payments/**")
            .uri("lb://payment-service"))
        .route("inventory_route", r -> r.path("/inventory/**")
            .uri("lb://inventory-service"))
        .build();
}

// Фильтр, добавляющий контекст пользователя в заголовки запроса
@Component
public class UserContextFilter extends AbstractGatewayFilterFactory<UserContextFilter.Config> {
    
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            
            // Получаем данные из JWT токена
            String authHeader = request.getHeaders().getFirst("Authorization");
            if (authHeader != null && authHeader.startsWith("Bearer ")) {
                String userId = extractUserIdFromToken(authHeader.substring(7));
                
                // Добавляем ID пользователя в заголовки для внутренних сервисов
                ServerHttpRequest modifiedRequest = request.mutate()
                    .header("X-User-Id", userId)
                    .build();
                
                return chain.filter(exchange.mutate().request(modifiedRequest).build());
            }
            
            return chain.filter(exchange);
        };
    }
    
    // ... остальной код класса
}

@Configuration
public class RibbonConfig {
    
    @Bean
    public IRule ribbonRule() {
        // Используем стратегию взвешенного отклика
        return new WeightedResponseTimeRule();
    }
}

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder, CircuitBreakerFactory cbFactory) {
    return builder.routes()
        .route("payment_service", r -> r.path("/payments/**")
            .filters(f -> f.circuitBreaker(c -> c
                .setName("paymentCircuitBreaker")
                .setFallbackUri("forward:/payment-fallback")))
            .uri("lb://payment-service"))
        .build();
}
 
@RestController
public class FallbackController {
    
    @GetMapping("/payment-fallback")
    public Mono<Map<String, String>> paymentFallback() {
        Map<String, String> response = new HashMap<>();
        response.put("status", "error");
        response.put("message", "Платежный сервис временно недоступен. Попробуйте позже.");
        return Mono.just(response);
    }
}

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("payment_api", r -> r.path("/api/payments/**")
            .filters(f -> f.requestRateLimiter(c -> c
                .setRateLimiter(redisRateLimiter())
                .setKeyResolver(userKeyResolver())))
            .uri("lb://payment-service"))
        .build();
}
 
@Bean
public RedisRateLimiter redisRateLimiter() {
    // Разрешаем 10 запросов в секунду с возможностью 20 запросов в пиковые нагрузки
    return new RedisRateLimiter(10, 20);
}
 
@Bean
KeyResolver userKeyResolver() {
    // Ограничение по IP-адресу
    return exchange -> Mono.just(
        exchange.getRequest().getRemoteAddress().getHostName()
    );
}

@Bean
public RouterFunction<ServerResponse> orderDetailsRoute() {
    return RouterFunctions.route(GET("/api/order-details/{id}"), request -> {
        String orderId = request.pathVariable("id");
        
        Mono<OrderDto> order = orderService.getOrder(orderId);
        Mono<PaymentDto> payment = paymentService.getPaymentByOrderId(orderId);
        Mono<ShipmentDto> shipment = shipmentService.getShipmentByOrderId(orderId);
        
        return Mono.zip(order, payment, shipment)
            .flatMap(tuple -> {
                OrderDetailsDto result = new OrderDetailsDto();
                result.setOrder(tuple.getT1());
                result.setPayment(tuple.getT2());
                result.setShipment(tuple.getT3());
                
                return ServerResponse.ok().bodyValue(result);
            })
            .onErrorResume(e -> {
                log.error("Ошибка при агрегации данных заказа: " + e.getMessage());
                return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .bodyValue(new ErrorResponse("Не удалось загрузить детали заказа"));
            });
    });
}

@Component
public class JwtAuthenticationFilter implements GlobalFilter {
 
private final JwtTokenValidator tokenValidator;
 
public JwtAuthenticationFilter(JwtTokenValidator tokenValidator) {
    this.tokenValidator = tokenValidator;
}
 
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    
    // Проверяем заголовок Authorization
    List<String> authHeaders = request.getHeaders().get("Authorization");
    if (authHeaders != null && !authHeaders.isEmpty()) {
        String authHeader = authHeaders.get(0);
        if (authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            
            // Валидируем JWT токен
            try {
                Claims claims = tokenValidator.validateToken(token);
                
                // Добавляем информацию из токена в заголовки для микросервисов
                ServerHttpRequest mutatedRequest = addClaimsToHeaders(request, claims);
                return chain.filter(exchange.mutate().request(mutatedRequest).build());
            } catch (Exception e) {
                // Возвращаем 401 при невалидном токене
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
        }
    }
    
    // Если нет токена, возможно, это публичный эндпоинт
    // Проверяем, требует ли путь аутентификации
    if (isSecuredPath(request.getPath().toString())) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }
    
    return chain.filter(exchange);
}
 
private boolean isSecuredPath(String path) {
    // Проверяем, нужна ли аутентификация для данного пути
    List<String> publicPaths = Arrays.asList("/auth/login", "/public", "/docs");
    return publicPaths.stream().noneMatch(path::startsWith);
}
 
private ServerHttpRequest addClaimsToHeaders(ServerHttpRequest request, Claims claims) {
    ServerHttpRequest.Builder builder = request.mutate();
    builder.header("X-User-Id", claims.getSubject());
    
    if (claims.get("roles") != null) {
        builder.header("X-User-Roles", claims.get("roles").toString());
    }
    
    if (claims.get("tenant") != null) {
        builder.header("X-Tenant-Id", claims.get("tenant").toString());
    }
    
    return builder.build();
}
}

@Configuration
@EnableWebFluxSecurity
public class SecurityConfig {
 
@Bean
public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
    return http
        .oauth2ResourceServer(oauth2 -> oauth2
            .jwt(jwt -> jwt.jwtAuthenticationConverter(grantedAuthoritiesConverter())))
        .authorizeExchange(exchanges -> exchanges
            .pathMatchers("/public/[B]").permitAll()
            .pathMatchers("/admin/[/B]").hasRole("ADMIN")
            .pathMatchers("/api/users/**").hasAnyRole("USER", "ADMIN")
            .anyExchange().authenticated())
        .build();
}
 
private Converter<Jwt, Mono<AbstractAuthenticationToken>> grantedAuthoritiesConverter() {
    JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(jwt -> {
        List<String> roles = jwt.getClaimAsStringList("roles");
        if (roles == null || roles.isEmpty()) {
            return Collections.emptyList();
        }
        return roles.stream()
            .map(role -> new SimpleGrantedAuthority("ROLE_" + role))
            .collect(Collectors.toList());
    });
    return new ReactiveJwtAuthenticationConverterAdapter(jwtAuthenticationConverter);
}
}

// Пример добавления контекста пользователя в сообщение Kafka
@Service
public class OrderService {
 
private final KafkaTemplate<String, OrderEvent> kafkaTemplate;
 
@Autowired
public OrderService(KafkaTemplate<String, OrderEvent> kafkaTemplate) {
    this.kafkaTemplate = kafkaTemplate;
}
 
public void createOrder(CreateOrderRequest request, UserContext userContext) {
    OrderEvent event = new OrderEvent();
    event.setOrderDetails(request);
    // Добавляем контекст пользователя в метаданные сообщения
    event.setUserId(userContext.getUserId());
    event.setTenantId(userContext.getTenantId());
    event.setRoles(userContext.getRoles());
    
    kafkaTemplate.send("orders-topic", event);
}
}

@Component
public class TenantFilter implements GlobalFilter {
 
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    
    // Получаем tenant ID из заголовка, JWT токена или из субдомена
    String tenantId = extractTenantId(request);
    
    if (tenantId != null) {
        // Добавляем tenant ID в заголовок для микросервисов
        ServerHttpRequest modifiedRequest = request.mutate()
            .header("X-Tenant-ID", tenantId)
            .build();
        
        return chain.filter(exchange.mutate().request(modifiedRequest).build());
    }
    
    return chain.filter(exchange);
}
 
private String extractTenantId(ServerHttpRequest request) {
    // Пример: извлечение tenant ID из JWT токена
    List<String> authHeaders = request.getHeaders().get("Authorization");
    if (authHeaders != null && !authHeaders.isEmpty()) {
        String authHeader = authHeaders.get(0);
        if (authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            return extractTenantFromToken(token);
        }
    }
    
    // Альтернативно, можно получить tenant ID из субдомена
    String host = request.getHeaders().getFirst("Host");
    if (host != null && host.contains(".")) {
        return host.split("\\.")[0];
    }
    
    return null;
}
 
private String extractTenantFromToken(String token) {
    // Логика извлечения tenant ID из JWT токена
    // ...
    return "tenant123"; // Пример значения
}
}

@Bean
public RouteLocator canaryRoutes(RouteLocatorBuilder builder) {
return builder.routes()
    // 90% трафика на стабильную версию
    .route("payment-service-stable", r -> r.weight("payment-group", 90)
        .and()
        .path("/payments/**")
        .uri("lb://payment-service"))
    // 10% на канареечную версию
    .route("payment-service-canary", r -> r.weight("payment-group", 10)
        .and()
        .path("/payments/**")
        .uri("lb://payment-service-v2"))
    .build();
}

// Конфигурация через properties
// Изначально используем "blue" окружение
spring.cloud.gateway.routes[0].id=current-environment
spring.cloud.gateway.routes[0].predicates[0]=Path=/**
spring.cloud.gateway.routes[0].uri=lb://blue-environment
 
// При деплое меняем всего одно свойство!
// spring.cloud.gateway.routes[0].uri=lb://green-environment

@Component
@RefreshScope // Для обновления весов без перезагрузки
public class WeightedRoutingConfig {
 
    @Value("${routing.payment-service.v1-weight:100}")
    private int v1Weight;
    
    @Value("${routing.payment-service.v2-weight:0}")
    private int v2Weight;
    
    @Bean
    public RouteLocator weightedRoutes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("payment-v1", r -> r
                .weight("payment-group", v1Weight)
                .and()
                .path("/payments/**")
                .uri("lb://payment-service-v1"))
            .route("payment-v2", r -> r
                .weight("payment-group", v2Weight)
                .and()
                .path("/payments/**")
                .uri("lb://payment-service-v2"))
            .build();
    }
}

@Bean
public RouteLocator abTestRoutes(RouteLocatorBuilder builder) {
return builder.routes()
    .route("recommendations-a", r -> r
        .cookie("ab-test-group", "A") // Маршрутизация по значению cookie
        .and()
        .path("/recommendations/**")
        .uri("lb://recommendations-classic"))
    .route("recommendations-b", r -> r
        .cookie("ab-test-group", "B")
        .and()
        .path("/recommendations/**")
        .uri("lb://recommendations-new-algo"))
    .route("recommendations-default", r -> r
        .path("/recommendations/**")
        .filters(f -> f
            // Если cookie нет, случайно назначаем группу
            .addResponseHeader("Set-Cookie", "ab-test-group=" + 
                (Math.random() > 0.5 ? "A" : "B") + "; Path=/; Max-Age=86400"))
        .uri("lb://recommendations-classic"))
    .build();
}

@Bean
public RouteLocator apiVersionRoutes(RouteLocatorBuilder builder) {
return builder.routes()
    // Версионирование через путь
    .route("users-v1", r -> r
        .path("/v1/users/**")
        .uri("lb://users-service-v1"))
    .route("users-v2", r -> r
        .path("/v2/users/**")
        .uri("lb://users-service-v2"))
    // Версионирование через заголовок
    .route("orders-v1", r -> r
        .path("/orders/**")
        .and()
        .header("X-API-Version", "1")
        .uri("lb://orders-service-v1"))
    .route("orders-v2", r -> r
        .path("/orders/**")
        .and()
        .header("X-API-Version", "2")
        .uri("lb://orders-service-v2"))
    // Версионирование через Accept header
    .route("products-v1", r -> r
        .path("/products/**")
        .and()
        .header("Accept", "application/vnd.company.v1+json")
        .uri("lb://products-service-v1"))
    .route("products-v2", r -> r
        .path("/products/**")
        .and()
        .header("Accept", "application/vnd.company.v2+json")
        .uri("lb://products-service-v2"))
    .build();
}

.route("legacy-compat", r -> r
    .path("/api/v1/legacy/**")
    .filters(f -> f
        .rewritePath("/api/v1/legacy/(?<segment>.*)", "/api/v2/${segment}")
        .addRequestHeader("X-API-Version", "2")
        .modifyRequestBody(String.class, String.class, (exchange, body) -> {
            // Преобразуем тело запроса из старого формата в новый
            return Mono.just(transformLegacyRequest(body));
        }))
    .uri("lb://modern-service"))

@Component
@RefreshScope
public class FeatureFlagsConfiguration {
    
    @Value("${features.new-payment-flow-enabled:false}")
    private boolean newPaymentFlowEnabled;
    
    @Bean
    public RouteLocator featureFlagRoutes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("payment-flow", r -> r
                .path("/payments/[B]")
                .filters(f -> {
                    if (newPaymentFlowEnabled) {
                        return f.setPath("/new-flow/payments/[/B]");
                    }
                    return f.setPath("/old-flow/payments/**");
                })
                .uri("lb://payment-service"))
            .build();
    }
}

@Bean
public RouteLocator contentBasedRoutes(RouteLocatorBuilder builder) {
return builder.routes()
    .route("payment-processing", r -> r
        .path("/api/payments/process")
        .and()
        .readBody(String.class, body -> {
            try {
                JsonNode json = new ObjectMapper().readTree(body);
                String country = json.path("customer").path("country").asText();
                // Запросы из США и Канады идут в североамериканский процессинг
                return "US".equals(country) || "CA".equals(country);
            } catch (Exception e) {
                return false;
            }
        })
        .uri("lb://na-payment-processor"))
    .route("payment-processing-eu", r -> r
        .path("/api/payments/process")
        .and()
        .readBody(String.class, body -> {
            try {
                JsonNode json = new ObjectMapper().readTree(body);
                String country = json.path("customer").path("country").asText();
                // Запросы из Европы идут в европейский процессинг
                List<String> euCountries = Arrays.asList("DE", "FR", "IT", "ES");
                return euCountries.contains(country);
            } catch (Exception e) {
                return false;
            }
        })
        .uri("lb://eu-payment-processor"))
    .route("payment-processing-default", r -> r
        .path("/api/payments/process")
        .uri("lb://default-payment-processor"))
    .build();
}

@Component
public class LoggingFilter implements GlobalFilter {
    
private final Logger logger = LoggerFactory.getLogger(this.getClass());
 
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    
    // Логируем входящий запрос
    logger.info("Processing {} request to {}", 
                request.getMethod(), 
                request.getURI());
    
    // Замеряем время выполнения
    long startTime = System.currentTimeMillis();
    
    return chain.filter(exchange).then(Mono.fromRunnable(() -> {
        ServerHttpResponse response = exchange.getResponse();
        long duration = System.currentTimeMillis() - startTime;
        
        // Логируем результат и время выполнения
        logger.info("Response status: {}, took: {}ms", 
                   response.getStatusCode(), 
                   duration);
    }));
}
}

@Component
public class CorrelationIdFilter implements GlobalFilter, Ordered {
 
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    
    // Проверяем, есть ли уже correlation ID в заголовках
    String correlationId = request.getHeaders().getFirst("X-Correlation-ID");
    
    // Если нет — генерируем новый
    if (correlationId == null || correlationId.isEmpty()) {
        correlationId = UUID.randomUUID().toString();
    }
    
    // Добавляем correlation ID в MDC для логирования
    MDC.put("correlationId", correlationId);
    
    // Добавляем correlation ID в заголовки для downstream сервисов
    ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
        .header("X-Correlation-ID", correlationId)
        .build();
    
    return chain.filter(
        exchange.mutate().request(mutatedRequest).build()
    ).doFinally(signalType -> MDC.remove("correlationId"));
}
 
@Override
public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE;
}
}

@Configuration
public class MetricsConfig {
 
@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
    return registry -> registry.config()
        .commonTags("application", "api-gateway");
}
 
@Bean
public TimedAspect timedAspect(MeterRegistry registry) {
    return new TimedAspect(registry);
}
}
 
@Component
public class MetricsFilter implements GlobalFilter, Ordered {
 
private final MeterRegistry meterRegistry;
 
public MetricsFilter(MeterRegistry meterRegistry) {
    this.meterRegistry = meterRegistry;
}
 
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    long startTime = System.currentTimeMillis();
    
    String path = exchange.getRequest().getPath().value();
    String method = exchange.getRequest().getMethod().toString();
    
    return chain.filter(exchange)
        .doFinally(signalType -> {
            long duration = System.currentTimeMillis() - startTime;
            
            // Записываем метрики времени ответа
            Timer.builder("gateway.request.duration")
                .tag("path", path)
                .tag("method", method)
                .tag("status", exchange.getResponse().getStatusCode().toString())
                .register(meterRegistry)
                .record(duration, TimeUnit.MILLISECONDS);
            
            // Считаем количество запросов
            Counter.builder("gateway.request.count")
                .tag("path", path)
                .tag("method", method)
                .register(meterRegistry)
                .increment();
        });
}
 
@Override
public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE + 1;
}
}

@Bean
public RouteLocator routes(RouteLocatorBuilder builder, CircuitBreakerFactory cbFactory) {
return builder.routes()
    .route("user-service", r -> r.path("/users/**")
        .filters(f -> f
            // Проверяем статус сервиса каждые 30 секунд
            .filter(new HealthCheckGatewayFilterFactory(
                "http://user-service/actuator/health",
                30000,
                "DOWN"))
            // Если сервис недоступен, используем Circuit Breaker
            .circuitBreaker(c -> c
                .setName("userServiceCircuit")
                .setFallbackUri("forward:/fallback/users")))
        .uri("lb://user-service"))
    .build();
}

@Configuration
public class TracingConfiguration {
 
    @Bean
    public Tracer jaegerTracer() {
        SamplerConfiguration samplerConfig = SamplerConfiguration
            .fromEnv()
            .withType("const")
            .withParam(1);
        
        ReporterConfiguration reporterConfig = ReporterConfiguration
            .fromEnv()
            .withLogSpans(true);
        
        return Configuration
            .fromEnv("api-gateway")
            .withSampler(samplerConfig)
            .withReporter(reporterConfig)
            .getTracer();
    }
    
    @Bean
    public WebFilter tracingFilter(Tracer tracer) {
        return new TracingWebFilter(tracer);
    }
}

@Configuration
public class GraphQLConfig {
 
    @Bean
    public GraphQLBridgeFilter graphQLFilter(
            List<GraphQLDataFetcher> dataFetchers, TypeDefinitionRegistry registry) {
        GraphQLSchema schema = buildSchema(registry, dataFetchers);
        return new GraphQLBridgeFilter("/graphql", schema);
    }
    
    @Bean
    public TypeDefinitionRegistry typeDefinitions() {
        // Объединяем схемы из разных сервисов
        SchemaParser parser = new SchemaParser();
        TypeDefinitionRegistry registry = new TypeDefinitionRegistry();
        
        // Добавляем схему из сервиса пользователей
        registry.merge(parser.parse(new ClassPathResource("schemas/users.graphql")));
        
        // Добавляем схему из сервиса заказов
        registry.merge(parser.parse(new ClassPathResource("schemas/orders.graphql")));
        
        return registry;
    }
}

@Bean
public RouteLocator routesWithCaching(RouteLocatorBuilder builder, RedisCacheManager cacheManager) {
    return builder.routes()
        .route("products", r -> r
            .path("/products/**")
            .filters(f -> f
                .cache(c -> c
                    .cacheManager(cacheManager)
                    // Кешируем только GET запросы
                    .predicate(exchange -> 
                        exchange.getRequest().getMethod() == HttpMethod.GET)
                    // TTL 5 минут для категорий товаров
                    .timeToLive(Duration.ofMinutes(5))
                    // Ключ кеша — по пути и параметрам запроса
                    .cacheKeyGenerator(exchange -> 
                        exchange.getRequest().getURI().getPath() + 
                        exchange.getRequest().getQueryParams().toString())
                )
            )
            .uri("lb://product-service"))
        .build();
}

@Bean
public RouteLocator securityEnhancedRoutes(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("secured-routes", r -> r
            .path("/**")
            .filters(f -> f
                // Защита от XSS
                .addResponseHeader("X-XSS-Protection", "1; mode=block")
                // Защита от Clickjacking
                .addResponseHeader("X-Frame-Options", "DENY")
                // Content Security Policy
                .addResponseHeader("Content-Security-Policy", 
                    "default-src 'self'; script-src 'self' https://trusted.cdn.com")
                // Защита от CSRF
                .csrfProtection()
                // Валидация входных данных
                .requestValidator(new InputValidationFilter())
            )
            .uri("lb://backend-services"))
        .build();
}

@Bean
public RedisRateLimiter customRedisRateLimiter(
        ReactiveRedisTemplate<String, String> redisTemplate,
        @Value("${rate-limiter.default-replenish-rate:100}") int defaultReplenishRate,
        @Value("${rate-limiter.default-burst-capacity:200}") int defaultBurstCapacity) {
    
    return new CustomRedisRateLimiter(redisTemplate, defaultReplenishRate, defaultBurstCapacity);
}

@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(5)) // Дефолтное TTL - 5 минут
        .serializeKeysWith(
            RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
        .serializeValuesWith(
            RedisSerializationContext.SerializationPair.fromSerializer(
                new GenericJackson2JsonRedisSerializer()));
    
    // Разные настройки для разных типов данных
    Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
    configMap.put("productCache", config.entryTtl(Duration.ofHours(1)));
    configMap.put("categoryCache", config.entryTtl(Duration.ofHours(3)));
    configMap.put("userCache", config.entryTtl(Duration.ofMinutes(30)));
    
    return RedisCacheManager.builder(connectionFactory)
        .cacheDefaults(config)
        .withInitialCacheConfigurations(configMap)
        .build();
}

@Configuration
public class GatewayConfig {
 
    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder, 
                                    RateLimiter rateLimiter,
                                    CircuitBreakerFactory cbFactory) {
        return builder.routes()
            // Маршруты для поисковых сервисов с кешированием
            .route("search-service", r -> r.path("/search/**")
                .filters(f -> f
                    .requestRateLimiter(c -> c
                        .setRateLimiter(rateLimiter)
                        .setKeyResolver(new IpAddressKeyResolver()))
                    .circuitBreaker(c -> c
                        .setName("searchCircuitBreaker")
                        .setFallbackUri("forward:/fallback/search"))
                    .cacheResponse(config -> config
                        .timeToLive(Duration.ofMinutes(10)))
                    .retry(retryConfig -> retryConfig
                        .setRetries(3)
                        .setMethods(HttpMethod.GET)
                        .setBackoff(Duration.ofMillis(100), 
                                  Duration.ofSeconds(1), 
                                  2, true))
                    .addResponseHeader("X-Cache-Status", "HIT"))
                .uri("lb://search-service"))
            
            // Маршруты для платежных сервисов с усиленной безопасностью
            .route("payment-service", r -> r.path("/payments/**")
                .filters(f -> f
                    .secureHeaders()
                    .addResponseHeader("Strict-Transport-Security", 
                                     "max-age=31536000; includeSubDomains")
                    .circuitBreaker(c -> c
                        .setName("paymentCircuitBreaker")
                        .setFallbackUri("forward:/fallback/payment"))
                    .retry(retryConfig -> retryConfig
                        .setRetries(1) // Для платежей минимум ретраев
                        .setMethods(HttpMethod.POST)
                        .setExceptions(SocketTimeoutException.class)))
                .uri("lb://payment-service"))
            
            // Другие маршруты...
            .build();
    }
    
    @Bean
    public WebFilter corsFilter() {
        return (ServerWebExchange ctx, WebFilterChain chain) -> {
            ServerHttpRequest request = ctx.getRequest();
            ServerHttpResponse response = ctx.getResponse();
            
            HttpHeaders headers = response.getHeaders();
            headers.add("Access-Control-Allow-Origin", "*");
            headers.add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
            headers.add("Access-Control-Allow-Headers", "Authorization, Content-Type");
            
            if (request.getMethod() == HttpMethod.OPTIONS) {
                response.setStatusCode(HttpStatus.OK);
                return Mono.empty();
            }
            
            return chain.filter(ctx);
        };
    }
}