Фаза 4: Проксирование запроса к целевому сервису

После выполнения всех pre-фильтров управление доходит до ключевого фильтра — NettyRoutingFilter (или WebClientHttpRoutingFilter в альтернативной реализации). Именно этот фильтр выполняет фактическое проксирование запроса к целевому сервису.

Процесс проксирования включает несколько шагов:
Преобразование URI назначения: Если URI маршрута использует схему lb:// (например, lb://USER-SERVICE), вызывается LoadBalancerClientFilter (или реактивный ReactorLoadBalancer), который преобразует логическое имя сервиса в физический адрес, выбирая конкретный экземпляр с учётом алгоритма балансировки нагрузки.

Подготовка запроса прокси: NettyRoutingFilter создаёт новый HTTP-запрос Netty, копируя метод, заголовки и тело из оригинального запроса. При этом он может применять трансформации, определённые фильтрами (например, перезапись пути, добавление заголовков).

Асинхронное выполнение запроса: Запрос отправляется через реактивный HTTP-клиент Netty (HttpClient). Клиент Netty работает в неблокирующем режиме — он ставит запрос в очередь на отправку и немедленно возвращает Mono<HttpClientResponse> без блокировки потока. Event loop thread освобождается для обработки других соединений.

Обработка ответа: Когда от целевого сервиса приходит ответ, Netty генерирует событие, которое обрабатывается реактивным pipeline. Тело ответа также остаётся в реактивном представлении (Flux<DataBuffer>), что позволяет streamingly передавать большие ответы без буферизации в памяти.

Конфигурация для балансировки нагрузки с помощью Spring Cloud LoadBalancer:

spring:
  cloud:
    gateway:
      routes:
      - id: user_service_lb
        uri: lb://user-service
        predicates:
        - Path=/users/**
        
    loadbalancer:
      configurations: default
      
    # Конфигурация для кэширования resolved адресов
    discovery:
      locator:
        enabled: true
        lower-case-service-id: true
При использовании lb:// схема автоматически активирует интеграцию с Service Discovery (Eureka, Consul) через ReactiveLoadBalancer. Выбор экземпляра выполняется с учётом состояния здоровья и выбранного алгоритма (round-robin по умолчанию).

Фаза 5: Пост-обработка ответа и завершение

После получения ответа от целевого сервиса выполняется оставшаяся часть цепочки фильтров — post-фильтры. Эти фильтры получают доступ как к оригинальному запросу, так и к ответу от целевого сервиса. Они могут модифицировать статус-код, заголовки, тело ответа.

Пример post-фильтра для добавления стандартных заголовков безопасности:

@Component
public class SecurityHeadersGlobalFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            ServerHttpResponse response = exchange.getResponse();
            if (!response.getHeaders().containsKey("X-Content-Type-Options")) {
                response.getHeaders().add("X-Content-Type-Options", "nosniff");
            }
            if (!response.getHeaders().containsKey("X-Frame-Options")) {
                response.getHeaders().add("X-Frame-Options", "DENY");
            }
            if (!response.getHeaders().containsKey("Content-Security-Policy")) {
                response.getHeaders().add("Content-Security-Policy", 
                    "default-src 'self'; frame-ancestors 'none'");
            }
        }));
    }
}
Важно отметить, что этот фильтр реализует интерфейс GlobalFilter и будет применён ко всем маршрутам автоматически. Глобальные фильтры выполняются до фильтров, специфичных для маршрута, если только их порядок (через аннотацию @Order или реализацию Ordered) не указывает иное.

После выполнения всех post-фильтров финальный ответ записывается обратно в исходный канал Netty к клиенту. Netty берёт на себя эффективную отправку данных, включая chunked encoding для stream-ответов.


#Java #middle #Spring_Cloud_Gateway

Типы фильтров и их специализация

Pre-filters / Post-filters — это логическая группировка, определяемая моментом выполнения относительно вызова целевого сервиса. Технически большинство фильтров могут работать и как pre, и как post, в зависимости от их реализации. Паттерн разделения на pre/post часто реализуется через вызов chain.filter(exchange).then(...) для post-логики.

Сетевые фильтры (Netty layer) работают на более низком уровне, ближе к транспорту. NettyRoutingFilter и NettyWriteResponseFilter являются примерами таких фильтров. Они манипулируют непосредственно объектами Netty (HttpClientRequest, HttpClientResponse) и работают с реактивными потоками байтов (ByteBuf). Эти фильтры критически важны для производительности, так как обеспечивают эффективную передачу данных без лишних копирований.

Global filters применяются ко всем маршрутам автоматически. Они регистрируются как Spring Beans и могут быть упорядочены. Типичные use cases: централизованное логирование, сбор метрик, добавление стандартных заголовков, кэширование. Глобальные фильтры выполняются до фильтров маршрута, если только их порядок не указывает иное.

Per-route filters конфигурируются для конкретных маршрутов и применяются только к ним. Они декларативно задаются в конфигурации маршрута (YAML, properties) или через Java DSL.

Пример сложного per-route фильтра с кастомной конфигурацией:

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("custom_rewrite", r -> r
            .path("/legacy/api/**")
            .filters(f -> f
                .rewritePath("/legacy/api/(?<segment>.*)", "/modern/${segment}")
                .addRequestParameter("source", "gateway")
                .circuitBreaker(config -> config
                    .setName("myCircuitBreaker")
                    .setFallbackUri("forward:/fallback/default"))
            )
            .uri("lb://backend-service"))
        .build();
}
В этой конфигурации DSL демонстрируется несколько фильтров в цепочке: rewritePath изменяет путь запроса с помощью регулярного выражения, addRequestParameter добавляет параметр, а circuitBreaker оборачивает вызов в контур устойчивости с fallback.

Управление памятью и производительностью в JVM

Архитектура SCG на Reactor Netty имеет глубокие последствия для управления памятью в JVM.

Вместо пулов потоков с фиксированным размером стека, основное потребление памяти связано с:
Буферами Netty (ByteBuf): Netty использует пул буферов через ByteBufAllocator. Это позволяет эффективно переиспользовать буферы для чтения/записи данных, минимизируя аллокации и сборку мусора. Буферы могут быть off-heap (direct buffers), что уменьшает нагрузку на GC, но требует явного управления памятью.

Реактивные потоки и лямбда-выражения: Каждый запрос создаёт цепочку реактивных операторов (Mono, Flux), которые представляются как объекты в heap. Лямбда-выражения в фильтрах также становятся объектами. Хотя эти объекты обычно недолгоживущие (short-lived) и эффективно обрабатываются молодым поколением сборщика мусора (young generation GC), при высокой нагрузке может создаваться значительное давление на GC.

Кэши маршрутов и предикатов: CachingRouteLocator и компилированные PathPattern кэшируются, что увеличивает постоянное потребление памяти (old generation), но значительно ускоряет обработку запросов.

Для оптимизации производительности важно:
Настроить размеры пулов буферов Netty согласно ожидаемому размеру запросов/ответов
Использовать профилирование для выявления memory leaks в кастомных фильтрах (невыполненные подписки на реактивные потоки)
Настроить сборщик мусора для низких пауз (G1GC или Shenandoah для больших heap-ов)
Мониторить количество аллокаций и pressure на young generation через JMX или Micrometer


#Java #middle #Spring_Cloud_Gateway

Конфигурация маршрутов в Spring Cloud Gateway

Декларативная конфигурация через application.yml
Конфигурация через YAML-файлы является декларативным подходом, где маршруты определяются статически на этапе компиляции или до запуска приложения. Этот метод обеспечивает простоту чтения, версионирование через системы контроля версий и простоту аудита изменений.


Базовая структура конфигурации маршрута

В YAML маршруты конфигурируются через иерархию spring.cloud.gateway.routes. Каждый маршрут должен иметь уникальный идентификатор, URI назначения, список предикатов и опциональный список фильтров.

spring:
  cloud:
    gateway:
      routes:
        - id: user_service_route
          uri: http://localhost:8081
          predicates:
            - Path=/api/users/**
            - Method=GET,POST
            - Header=X-Requested-With, XMLHttpRequest
          filters:
            - StripPrefix=1
            - AddRequestHeader=X-Gateway-Version, v2.0
            - RewritePath=/api/users/(?<segment>.*), /$\{segment}
          metadata:
            response-timeout: 5000
            connect-timeout: 2000
            max-auto-retries: 3

Детализация предикатов

Предикаты в YAML конфигурируются как список строк, где каждая строка соответствует фабрике предикатов и её параметрам. Формат: Name=arg1,arg2,...,key1=value1,key2=value2.

Предикат Path:

predicates:
  - Path=/api/v1/.*
  - Path=/api/orders/{segment}, /api/products/{segment}
При использовании фигурных скобок {segment} происходит извлечение переменных пути, которые затем доступны в фильтрах через шаблоны типа ${segment}.

Составные предикаты с помощью After и Before:

predicates:
  - After=2023-01-20T17:42:47.789-07:00[America/Denver]
  - Between=2023-01-20T17:42:47.789-07:00[America/Denver],2023-01-21T17:42:47.789-07:00[America/Denver]
Временные предикаты используют формат даты-времени ISO-8601 и учитывают временные зоны. Они полезны для канарей-развёртываний и управления версиями API.

Предикат Query для проверки параметров:

predicates:
  - Query=version, ^v[0-9]+$
  - Query=token
Первый вариант проверяет, что параметр version существует и соответствует регулярному выражению. Второй вариант проверяет только наличие параметра token без проверки значения.

Предикат RemoteAddr для контроля доступа по IP:

predicates:
  - RemoteAddr=192.168.1.1/24, 10.0.0.1/8
Поддерживается CIDR-нотация. Этот предикат часто комбинируется с фильтрами аутентификации для создания многоуровневой безопасности.

Кастомный предикат с использованием SpEL:

predicates:
  - name: Custom
    args:
      name: myPredicate
      spel: "#{@tokenValidator.validate(request)}"
Для кастомных предикатов используется полная форма конфигурации с указанием имени и аргументов. SpEL (Spring Expression Language) позволяет вызывать Spring Beans и выполнять сложную логику.

Фильтры в YAML конфигурации

Фильтры определяют преобразования, применяемые к запросу или ответу. Они выполняются в порядке объявления.

Базовые фильтры преобразования:

filters:
  # Удаление частей пути
  - StripPrefix=2
  
  # Добавление заголовков
  - AddRequestHeader=X-Client-Version, 1.0.0
  - AddResponseHeader=X-Response-Time, "`new java.text.SimpleDateFormat('yyyy-MM-dd HH:mm:ss.SSS').format(new java.util.Date())`"
  
  # Установка пути
  - SetPath=/api/v2/{segment}
  
  # Изменение порта и хоста
  - SetRequestHost=api.example.com
  
  # Перенаправление
  - RedirectTo=302, https://secure.example.com

Фильтры для работы с телом запроса:

filters:
  # Модификация тела запроса (требует чтения всего тела в память)
  - ModifyRequestBody=com.example.JsonTransformer, application/json, application/json, 102400
  
  # Модификация тела ответа
  - ModifyResponseBody=com.example.ResponseNormalizer, application/json, application/json
  
  # Кэширование тела запроса для многократного чтения
  - CacheRequestBody=""

Фильтры модификации тела используют регистрируемые через Spring Beans трансформеры. Важно понимать, что они требуют чтения всего тела запроса в память, что может быть проблематично для больших payload.

#Java #middle #Spring_Cloud_Gateway

Фильтры устойчивости и ограничения:

filters:
  # Circuit Breaker с Resilience4J
  - name: CircuitBreaker
    args:
      name: userServiceBreaker
      fallbackUri: forward:/fallback/user
      statusCodes: 500,502,503
  
  # Ограничение частоты запросов с Redis
  - name: RequestRateLimiter
    args:
      redis-rate-limiter.replenishRate: 10
      redis-rate-limiter.burstCapacity: 20
      redis-rate-limiter.requestedTokens: 1
      key-resolver: "#{@userKeyResolver}"
  
  # Retry с экспоненциальной отсрочкой
  - name: Retry
    args:
      retries: 3
      statuses: BAD_GATEWAY,INTERNAL_SERVER_ERROR
      methods: GET,POST
      series: SERVER_ERROR
      backoff:
        firstBackoff: 50ms
        maxBackoff: 1000ms
        factor: 2
        basedOnPreviousValue: false

URI и метаданные

URI назначения поддерживает несколько схем:

uri: http://localhost:8081           # Прямой URL
uri: https://api.example.com:8443    # HTTPS
uri: lb://USER-SERVICE              # Балансировка нагрузки через Service Discovery
uri: ws://echo.example.com          # WebSocket
uri: forward:/fallback              # Внутреннее перенаправление

Схема lb:// активирует клиентскую балансировку нагрузки. При использовании с Service Discovery (Eureka, Consul) имя сервиса автоматически разрешается в список доступных экземпляров.

Метаданные маршрута предоставляют дополнительную конфигурацию, специфичную для маршрута:

metadata:
  # Таймауты для Netty
  response-timeout: 5000        # Таймаут ответа в миллисекундах
  connect-timeout: 2000         # Таймаут соединения
  max-auto-retries: 2           # Автоматические повторы для сетевых ошибок
  
  # Конфигурация для конкретных интеграций
  hystrix.commandName: userCommand
  metrics.tags: "service=user,version=v2"
  
  # Пользовательские метаданные
  feature-flags: "canary=true,experimental=false"
  sla: "p99<200ms"

Метаданные доступны в фильтрах через exchange.getAttribute(ROUTE_ATTRIBUTE).getMetadata() и могут использоваться для реализации динамического поведения.

#Java #middle #Spring_Cloud_Gateway

Java DSL: Fluent API для программируемой конфигурации

Java DSL через RouteLocatorBuilder предоставляет императивный способ определения маршрутов, который позволяет использовать всю мощь Java: условия, циклы, вызовы методов, dependency injection.

Базовый fluent-синтаксис

@Configuration
public class GatewayConfiguration {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user_route", r -> r
                .path("/api/users/**")
                .and()
                .method(HttpMethod.GET, HttpMethod.POST)
                .and()
                .header("X-API-Version", "v2")
                .filters(f -> f
                    .stripPrefix(1)
                    .addRequestHeader("X-Gateway-Route", "user")
                    .circuitBreaker(config -> config
                        .setName("userCircuitBreaker")
                        .setFallbackUri("forward:/fallback/user"))
                    .retry(config -> config
                        .setRetries(3)
                        .setStatuses(HttpStatus.INTERNAL_SERVER_ERROR, 
                                    HttpStatus.BAD_GATEWAY)
                        .setMethods(HttpMethod.GET)
                        .setBackoff(50, 200, 2, true))
                )
                .uri("lb://user-service")
                .metadata("response-timeout", 3000)
                .metadata("connect-timeout", 1000)
            )
            .route("product_route", r -> r
                .path("/api/products/**")
                .filters(f -> f
                    .rewritePath("/api/products/(?<segment>.*)", 
                                "/v2/products/${segment}")
                    .addResponseHeader("X-Cache-Control", "max-age=3600")
                    .requestRateLimiter(config -> config
                        .setRateLimiter(redisRateLimiter())
                        .setKeyResolver(userKeyResolver()))
                )
                .uri("lb://product-service")
            )
            .build();
    }
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20, 1);
    }
    
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest().getHeaders()
                .getFirst("X-User-Id")
        );
    }
}

Преимущества Java DSL перед YAML

1. Использование Spring Beans в конфигурации:

@Bean
public RouteLocator dynamicRouteLocator(
        RouteLocatorBuilder builder,
        FeatureFlagService featureService,
        CircuitBreakerRegistry breakerRegistry) {
    
    return builder.routes()
        .route("feature_route", r -> r
            .path("/experimental/**")
            .predicate(exchange -> {
                // Динамическая проверка feature flags
                boolean enabled = featureService.isEnabled(
                    "experimental_api", 
                    exchange.getRequest().getHeaders()
                        .getFirst("X-User-Id")
                );
                return enabled;
            })
            .filters(f -> f
                .circuitBreaker(config -> config
                    .setCircuitBreakerFactory(
                        new ReactiveResilience4JCircuitBreakerFactory(
                            breakerRegistry
                        )
                    )
                    .setName("experimentalBreaker")
                )
            )
            .uri("lb://experimental-service")
        )
        .build();
}

#Java #middle #Spring_Cloud_Gateway

2. Генерация маршрутов на основе данных из внешних источников:

@Bean
public RouteLocator generatedRoutes(
        RouteLocatorBuilder builder,
        RouteTemplateService templateService) {
    
    RouteLocatorBuilder.Builder routesBuilder = builder.routes();
    
    // Загрузка шаблонов маршрутов из базы данных
    List<RouteTemplate> templates = templateService.loadTemplates();
    
    for (RouteTemplate template : templates) {
        routesBuilder.route(template.getId(), r -> {
            RouteLocatorBuilder.Builder spec = r
                .path(template.getPathPattern())
                .uri(template.getTargetUri());
            
            // Динамическое добавление фильтров
            for (FilterConfig filterConfig : template.getFilters()) {
                spec.filters(f -> addFilterDynamically(f, filterConfig));
            }
            
            return spec;
        });
    }
    
    return routesBuilder.build();
}

3. Создание сложных составных предикатов:

@Bean
public RouteLocator complexPredicateRoute(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("business_rule_route", r -> r
            // Комбинация предикатов с кастомной логикой
            .asyncPredicate(exchange -> {
                return businessRuleEngine()
                    .evaluate(exchange.getRequest())
                    .map(BusinessDecision::isAllowed);
            })
            .and()
            .weight("group_a", 80)  // 80% трафика
            .and()
            .cookie("session_id", ".*")
            .filters(f -> f
                .modifyRequestBody(String.class, String.class,
                    (exchange, body) -> {
                        // Модификация тела на основе бизнес-правил
                        return Mono.just(
                            transformPayload(body, exchange)
                        );
                    }
                )
            )
            .uri("lb://primary-service")
        )
        .build();
}

Что можно делать только в DSL и нельзя в YAML

1. Использование произвольных Predicate<ServerWebExchange>:

.route("custom_predicate", r -> r
    .predicate(exchange -> {
        // Любая Java-логика
        String clientIp = exchange.getRequest()
            .getRemoteAddress()
            .getAddress()
            .getHostAddress();
        
        return !ipBlacklist.contains(clientIp) &&
               rateLimiter.tryAcquire(clientIp);
    })
    .uri("lb://service")
)

2. Интеграция с внешними системами конфигурации:

.route("external_config", r -> r
    .asyncPredicate(exchange -> {
        // Загрузка правил из внешнего сервиса
        return configClient.getRoutingRules()
            .map(rules -> rules.matches(exchange.getRequest()));
    })
    .filters((exchange, chain) -> {
        // Динамическая модификация на основе конфигурации
        ServerHttpRequest request = exchange.getRequest();
        Map<String, String> headers = externalConfig
            .getHeadersForRoute(request.getPath().toString());
        
        ServerHttpRequest mutated = request.mutate()
            .headers(h -> headers.forEach(h::add))
            .build();
        
        return chain.filter(
            exchange.mutate().request(mutated).build()
        );
    })
    .uri("lb://target")
)

#Java #middle #Spring_Cloud_Gateway

3. Генерация маршрутов в runtime:

@Bean
public RouteLocator runtimeGeneratedRoutes(
        RouteLocatorBuilder builder,
        ApplicationContext context) {
    
    RouteLocatorBuilder.Builder routes = builder.routes();
    
    // Динамическое создание маршрутов на основе Bean-ов
    Map<String, RouteProvider> providers = context
        .getBeansOfType(RouteProvider.class);
    
    providers.forEach((name, provider) -> {
        provider.getRoutes().forEach(routeDef -> {
            routes.route(routeDef.getId(), r -> {
                AbstractRouteSpec spec = r
                    .path(routeDef.getPath())
                    .uri(routeDef.getUri());
                
                routeDef.getFilters().forEach(filter -> {
                    spec.filters(f -> configureFilter(f, filter));
                });
                
                return spec;
            });
        });
    });
    
    return routes.build();
}

Динамическая маршрутизация

DiscoveryClientRouteDefinitionLocator

DiscoveryClientRouteDefinitionLocator обеспечивает автоматическое создание маршрутов на основе сервисов, зарегистрированных в Service Discovery. При активации, для каждого зарегистрированного сервиса создаётся маршрут, который перенаправляет трафик на этот сервис.

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true
          predicates:
            - name: Path
              args:
                pattern: "'/services/' + serviceId.toLowerCase() + '/**'"
          filters:
            - name: RewritePath
              args:
                regexp: "'/services/' + serviceId.toLowerCase() + '/(?<remaining>.*)'"
                replacement: "'/${remaining}'"

Эта конфигурация создаст маршруты вида:
http://gateway/services/user-service/** → lb://user-service
http://gateway/services/order-service/** → lb://order-service


Интеграция с Eureka

Для интеграции с Eureka необходимо добавить зависимость и соответствующую конфигурацию:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

eureka:
  client:
    service-url:
      defaultZone: http://eureka-server:8761/eureka
    registry-fetch-interval-seconds: 5
  instance:
    lease-renewal-interval-in-seconds: 10
    lease-expiration-duration-in-seconds: 30

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          # Добавление метаданных из Eureka в маршруты
          include-expression: metadata['gateway.enabled'] == 'true'
          url-expression: "'lb://' + serviceId"

Eureka-специфичные метаданные могут использоваться для управления маршрутизацией:

@Bean
public RouteLocator eurekaAwareRoutes(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("zone_aware", r -> r
            .path("/zone/**")
            .predicate(exchange -> {
                // Выбор экземпляра в той же зоне доступности
                ServiceInstance instance = loadBalancer.choose(
                    "target-service",
                    new ZonePreferenceServiceInstanceListSupplier()
                );
                return instance != null;
            })
            .uri("lb://target-service")
        )
        .build();
}

#Java #middle #Spring_Cloud_Gateway

Интеграция с Consul

Consul предоставляет более богатые возможности для service discovery и health checking:

spring:
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        health-check-path: /actuator/health
        health-check-interval: 10s
        tags:
          - gateway-enabled
          - version=v2
        query-passing: true  # Использовать только здоровые инстансы
    
    gateway:
      discovery:
        locator:
          enabled: true
          predicates:
            - name: Path
              args:
                pattern: "'/consul/' + serviceId + '/**'"
          filters:
            - name: RewritePath
              args:
                regexp: "'/consul/' + serviceId + '/(?<remaining>.*)'"
                replacement: "'/${remaining}'"
          # Фильтрация по Consul-тегам
          include-expression: tags.contains('gateway-enabled')

Consul теги могут использоваться для реализации сложной логики маршрутизации:

@Bean
public RouteLocator consulTagBasedRoutes(
        RouteLocatorBuilder builder,
        ConsulDiscoveryClient discoveryClient) {
    
    return builder.routes()
        .route("canary_route", r -> r
            .path("/api/canary/**")
            .predicate(exchange -> {
                // Динамическая канареечная маршрутизация
                List<ServiceInstance> instances = discoveryClient
                    .getInstances("product-service");
                
                // Выбор инстансов с тегом canary
                ServiceInstance canaryInstance = instances.stream()
                    .filter(inst -> inst.getMetadata()
                        .getOrDefault("canary", "false")
                        .equals("true"))
                    .findFirst()
                    .orElse(null);
                
                // 10% трафика на canary
                return canaryInstance != null && 
                       Math.random() < 0.1;
            })
            .uri("lb://product-service")
        )
        .build();
}

#Java #middle #Spring_Cloud_Gateway

Кастомный RouteDefinitionRepository

Для полностью динамической маршрутизации можно реализовать собственный RouteDefinitionRepository, который будет загружать маршруты из произвольного источника (БД, файловая система, внешний сервис).

Базовая реализация с поддержкой обновлений:

@Component
public class DatabaseRouteDefinitionRepository 
        implements RouteDefinitionRepository, ApplicationEventPublisherAware {
    
    private final RouteDefinitionDAO routeDefinitionDAO;
    private final Map<String, RouteDefinition> cache = 
        new ConcurrentHashMap<>();
    private ApplicationEventPublisher publisher;
    
    public DatabaseRouteDefinitionRepository(
            RouteDefinitionDAO routeDefinitionDAO) {
        this.routeDefinitionDAO = routeDefinitionDAO;
        loadRoutes();
    }
    
    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        return Flux.fromIterable(cache.values());
    }
    
    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        return route.flatMap(routeDef -> {
            return routeDefinitionDAO.save(routeDef)
                .doOnSuccess(saved -> {
                    cache.put(saved.getId(), saved);
                    publishRefreshEvent();
                })
                .then();
        });
    }
    
    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        return routeId.flatMap(id -> {
            return routeDefinitionDAO.delete(id)
                .doOnSuccess(deleted -> {
                    cache.remove(id);
                    publishRefreshEvent();
                })
                .then();
        });
    }
    
    private void loadRoutes() {
        routeDefinitionDAO.findAll()
            .doOnNext(routeDef -> cache.put(routeDef.getId(), routeDef))
            .subscribe();
    }
    
    private void publishRefreshEvent() {
        if (publisher != null) {
            publisher.publishEvent(
                new RefreshRoutesEvent(this)
            );
        }
    }
    
    @Override
    public void setApplicationEventPublisher(
            ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    
    // Метод для внешних триггеров обновления
    @Scheduled(fixedDelay = 30000)
    public void refreshRoutes() {
        loadRoutes();
        publishRefreshEvent();
    }
}

Реализация с поддержкой веб-интерфейса для управления маршрутами:

@RestController
@RequestMapping("/api/gateway/routes")
public class RouteManagementController {
    
    private final RouteDefinitionWriter routeDefinitionWriter;
    private final RouteDefinitionLocator routeDefinitionLocator;
    
    @PostMapping
    public Mono<ResponseEntity<Void>> createRoute(
            @RequestBody RouteDefinition routeDefinition) {
        return routeDefinitionWriter
            .save(Mono.just(routeDefinition))
            .then(Mono.just(ResponseEntity.ok().build()));
    }
    
    @GetMapping
    public Flux<RouteDefinition> getAllRoutes() {
        return routeDefinitionLocator.getRouteDefinitions();
    }
    
    @PutMapping("/{id}")
    public Mono<ResponseEntity<Void>> updateRoute(
            @PathVariable String id,
            @RequestBody RouteDefinition routeDefinition) {
        
        return routeDefinitionWriter
            .delete(Mono.just(id))
            .then(routeDefinitionWriter.save(Mono.just(routeDefinition)))
            .then(Mono.just(ResponseEntity.ok().build()));
    }
    
    @DeleteMapping("/{id}")
    public Mono<ResponseEntity<Void>> deleteRoute(@PathVariable String id) {
        return routeDefinitionWriter
            .delete(Mono.just(id))
            .then(Mono.just(ResponseEntity.noContent().build()));
    }
}

#Java #middle #Spring_Cloud_Gateway

Интеграция с внешними системами конфигурации:

@Component
public class ExternalConfigRouteDefinitionRepository 
        implements RouteDefinitionRepository {
    
    private final ConfigClient configClient;
    private final AtomicReference<List<RouteDefinition>> cachedRoutes = 
        new AtomicReference<>(Collections.emptyList());
    
    public ExternalConfigRouteDefinitionRepository(
            ConfigClient configClient) {
        this.configClient = configClient;
        configClient.watchRoutes()
            .doOnNext(this::updateRoutes)
            .subscribe();
    }
    
    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        return Flux.fromIterable(cachedRoutes.get());
    }
    
    private void updateRoutes(List<RouteConfig> routeConfigs) {
        List<RouteDefinition> routeDefinitions = routeConfigs.stream()
            .map(this::convertToRouteDefinition)
            .collect(Collectors.toList());
        
        cachedRoutes.set(routeDefinitions);
        
        // Генерация события обновления маршрутов
        SpringApplication.publishEvent(
            new RefreshRoutesEvent(this)
        );
    }
    
    private RouteDefinition convertToRouteDefinition(
            RouteConfig config) {
        RouteDefinition definition = new RouteDefinition();
        definition.setId(config.getId());
        definition.setUri(URI.create(config.getUri()));
        
        // Конвертация предикатов
        config.getPredicates().forEach((name, args) -> {
            PredicateDefinition predicate = new PredicateDefinition();
            predicate.setName(name);
            predicate.setArgs(args);
            definition.getPredicates().add(predicate);
        });
        
        // Конвертация фильтров
        config.getFilters().forEach((name, args) -> {
            FilterDefinition filter = new FilterDefinition();
            filter.setName(name);
            filter.setArgs(args);
            definition.getFilters().add(filter);
        });
        
        definition.setMetadata(config.getMetadata());
        return definition;
    }
    
    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        // Делегирование сохранения во внешнюю систему
        return route.flatMap(routeDef -> 
            configClient.saveRoute(convertToRouteConfig(routeDef))
        ).then();
    }
    
    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        return routeId.flatMap(id -> 
            configClient.deleteRoute(id)
        ).then();
    }
}

Обработка событий обновления маршрутов:

@Component
public class RouteUpdateListener {
    
    private final RouteRefreshListener routeRefreshListener;
    
    @EventListener
    public void handleRefreshRoutesEvent(RefreshRoutesEvent event) {
        // Логирование обновления маршрутов
        logger.info("Routes refreshed by {}", event.getSource());
        
        // Метрики
        meterRegistry.counter("gateway.routes.refresh").increment();
        
        // Уведомление подписчиков
        routeRefreshListener.notifyRefresh();
    }
    
    @EventListener
    public void handleApplicationEvent(ApplicationEvent event) {
        if (event instanceof InstanceRegisteredEvent) {
            // Обработка регистрации нового инстанса
            updateRoutesForNewInstance(
                ((InstanceRegisteredEvent) event).getInstance()
            );
        }
    }
}

#Java #middle #Spring_Cloud_Gateway

Predicates (условия маршрутизации)

Predicates в Spring Cloud Gateway — это функции, которые принимают ServerWebExchange и возвращают boolean, определяя, попадает ли входящий запрос под конкретный Route. Predicates — фундамент маршрутизации: маршрут считается подходящим только если все его предикаты возвращают true (логическое AND между перечисленными предикатами одного маршрута). Понимание механизмов работы предикатов критично для корректного и производительного построения маршрутов.


Ключевые принципы — механика и порядок

Маршрут выбран, если все его предикаты истинны.
В конфигурации YAML или Java DSL, когда у Route указано несколько предикатов, они объединяются логически через AND.

Порядок маршрутов важен.
Gateway перебирает доступные маршруты в порядке, определённом компонентом, который предоставляет Flux<Route> (обычно RouteDefinitionLocator → RouteDefinitionRouteLocator). Конкретный порядок определяется полем order (если задано) или порядком получения/создания маршрутов. Первый подходящий маршрут (в смысле совпадения предикатов) берётся в обработку. Следовательно, дешёвые «фильтрующие» предикаты (например, Host, Method) следует располагать раньше в конфигурации маршрутов по логике — не путать с порядком предикатов в одном маршруте: в одном маршруте порядок предикатов обычно не меняет семантику, но влияет на порядок выполнения (см. рекомендации по эффективности ниже).

Оценка предикатов — последовательная и краткая:
Для одного маршрута предикаты обычно вычисляются последовательно и, при первом false, дальнейшая проверка предикатов для этого маршрута останавливается (short-circuit). Тем не менее, поскольку маршрутов может быть много, Gateway продолжит проверять следующие маршруты до нахождения первого подходящего.

Рекомендации по производительности:
Помещайте дешёвые и часто отсекающие проверки (например, Host, Method, Path) до дорогих вычислений (например, проверки содержимого тела, обращения в внешние сервисы или сложных регулярных выражений).

Избегайте предикатов, которые делают блокирующие операции — predicated должны быть чисто вычислительными и быстрыми. При необходимости используйте Java DSL и инкапсулируйте асинхронную работу в фильтрах, а не в предикатах.

Если нужна сложная проверка, лучше вынести её в отдельный, оптимизированный RoutePredicateFactory (см. ниже).

Композиция логики (AND/OR):
AND — поведение по умолчанию: несколько предикатов в одном Route объединяются через AND.
OR — декларативно не представлен как оператор на уровне одной записи YAML; для выражения OR чаще используют либо несколько маршрутов с разными наборами предикатов, либо пишут кастомный предикат, который внутри реализует логическое OR. В Java DSL также проще объявить несколько маршрутов или написать композиционный предикат в коде.


Встроенные предикаты — семантика, YAML-примеры, Java DSL-примеры

Ниже даны наиболее часто используемые предикаты, их поведение и примеры конфигурации.

1) Path
Проверяет соответствие URL-пути. Поддерживает шаблоны в стиле Ant (/users/**, /api/*/items) и также поддерживает регулярные группы при использовании Rewrite и фильтров.

YAML:

predicates:
  - Path=/api/users/** 

Java DSL:

.route("users", r -> r.path("/api/users/**")
                     .uri("lb://user-service"))

Замечание: Path — обычно самый дешёвый и самый часто используемый предикат; ставьте его в начале списка логических проверок маршрутов.

2) Host
Проверяет заголовок Host (например, api.example.com). Поддерживает подстановки (*.example.com).

YAML:

predicates:
  - Host=api.example.com, *.internal.example.org

Java DSL:

.route("host-route", r -> r.host("api.example.com", "*.internal.example.org")
                           .uri("http://localhost:8080"))

Заметка: Host — особенно полезен при мульти-тенантной конфигурации.


#Java #middle #Spring_Cloud_Gateway

3) Method
Сравнивает HTTP-метод (GET/POST/PUT/...).

YAML:

predicates:
  - Method=GET,POST

Java DSL:

.route("read-write", r -> r.method(HttpMethod.GET, HttpMethod.POST)
                           .uri("lb://some-service"))

4) Header
Проверяет наличие и (при задании) значение заголовка. Поддерживает регулярные выражения на значение.

YAML:

predicates:
  - Header=X-Client, ^mobile-.*

Java DSL:

.route("header-route", r -> r.header("X-Client", "^mobile-.*")
                              .uri("http://mobile-backend"))

Если значение не указано — проверяется только наличие заголовка.

5) Query
Проверяет наличие параметра query и, при наличии второго аргумента, — значение (регулярное выражение).

YAML:

predicates:
  - Query=version, ^v[0-9]+$

Java DSL:

.route("versioned", r -> r.query("version", "^v[0-9]+$")
                           .uri("lb://versioned-service"))

6) RemoteAddr
Проверяет IP-адрес клиента — поддерживает одиночные адреса и CIDR. Важно: в случае проксирования через балансировщики/Gateway заранее убедитесь, какие IP попадают в RemoteAddr (реальный клиент или IP reverse-proxy). Иногда требуется проверка X-Forwarded-For.

YAML:

predicates:
  - RemoteAddr=192.168.1.0/24, 10.0.0.10

Java DSL:

.route("internal-only", r -> r.remoteAddr("192.168.0.0/16", "10.0.0.0/8")
                              .uri("lb://internal-service"))

7) Weight / Load Balancer predicates (логика распределения) — концепция и применение
Weight — предикат, встречающийся в экосистеме Spring Cloud Gateway в контексте динамических маршрутов и Discovery клиента. Его цель — поддержка взвешенной маршрутизации: когда один и тот же serviceId представлен несколькими маршрутами с разными весами (weight), Gateway на этапе выбора маршрута учитывает веса (для канареечных релизов, A/B, geo-aware routing и т.п.).

Практическая схема использования:
Discovery-driven маршрутизация (DiscoveryClientRouteDefinitionLocator) может генерировать маршруты для каждого экземпляра/группы с метаданными веса.
Weight-предикат в составе маршрута проверяет — подходит ли текущий запрос под данный «весовой» маршрут (обычно реализуется через случайное/round-robin решение, зависящее от weight).

Примечание по реализации и совместимости: синтаксис и встроенные реализации могут различаться между версиями Spring Cloud.

Если требуется взвешенная маршрутизация в production, часто применяют:
Spring Cloud LoadBalancer для распределения трафика по инстансам;
Weight-подход в комбинировании с DiscoveryClientRouteDefinitionLocator или кастомным RouteDefinitionRepository.
Если нужен пример конфигурации — лучше реализовать weight механизмы через Discovery + metadata на стороне сервисов или через кастомный RoutePredicateFactory (пример ниже покажет, как писать свой предикат).


Сложные комбинации — AND / OR / NOT

AND: стандартная комбинация — несколько предикатов в одном Route → все должны быть true. Шаблон конфигурирования одинаков как в YAML, так и в DSL.

OR: декларативного OR в одном Route нет.

Для выражения OR есть два варианта:
Несколько маршрутов: создайте два (или больше) маршрута, каждый с различным предикатом; порядок важен, если маршруты пересекаются.
Кастомный предикат (composite): напишите RoutePredicateFactory, который внутри реализует логику a || b, и используйте его как обычный предикат. Это предпочтительно, если хотите избежать дублирования конфигурации и централизовать логику.

NOT / Negation: также не представлен в YAML как отдельный оператор; реализуется кастомным предикатом или путём композиции (например, создание предиката NotHeader).


#Java #middle #Spring_Cloud_Gateway

Написание собственного Predicate — RoutePredicateFactory

Когда встроенных предикатов недостаточно по логике или производительности, пишут собственные RoutePredicateFactory. Ниже — полный пример: реализуем предикат, который проверяет наличие параметра X-Feature и сопоставляет его по списку допустимых значений, при этом конфигурируемый через YAML.

1) Структура — класс предиката

import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.web.server.ServerWebExchange;
import java.util.function.Predicate;
import java.util.List;

public class XFeatureRoutePredicateFactory extends AbstractRoutePredicateFactory<XFeatureRoutePredicateFactory.Config> {

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

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        List<String> allowed = config.getAllowedValues();
        boolean ignoreCase = config.isIgnoreCase();

        return exchange -> {
            List<String> headerValues = exchange.getRequest().getHeaders().get("X-Feature");
            if (headerValues == null || headerValues.isEmpty()) {
                return false;
            }
            for (String hv : headerValues) {
                for (String allowedVal : allowed) {
                    if (ignoreCase) {
                        if (hv.equalsIgnoreCase(allowedVal)) return true;
                    } else {
                        if (hv.equals(allowedVal)) return true;
                    }
                }
            }
            return false;
        };
    }

    public static class Config {
        private List<String> allowedValues;
        private boolean ignoreCase = true;

        public List<String> getAllowedValues() { return allowedValues; }
        public void setAllowedValues(List<String> allowedValues) { this.allowedValues = allowedValues; }
        public boolean isIgnoreCase() { return ignoreCase; }
        public void setIgnoreCase(boolean ignoreCase) { this.ignoreCase = ignoreCase; }
    }
}

Ключевые моменты:
Наследуемся от AbstractRoutePredicateFactory<Config>. Это даёт поддержку автоконфигурируемой десериализации конфигурации из YAML в Config.
apply(Config) возвращает Predicate<ServerWebExchange>, который будет выполняться для каждого запроса.
Config — POJO с геттерами/сеттерами: Spring автоматически маппит значения из YAML (через Binder).

2) Регистрация (component или bean)

import org.springframework.stereotype.Component;

@Component
public class XFeatureRoutePredicateFactory extends AbstractRoutePredicateFactory<XFeatureRoutePredicateFactory.Config> {
    // ... код как выше
}

Если не использовать @Component, можно зарегистрировать как bean через конфигурацию.

3) Использование в YAML

spring:
  cloud:
    gateway:
      routes:
        - id: feature-route
          uri: http://feature-service
          predicates:
            - XFeature=allowed1,allowed2

В AbstractRoutePredicateFactory стандартная разбивка аргументов (если конфиг простой) позволит подставить список значений. Для более сложной настройки (ключ:значение) необходимо переопределить shortcutFieldOrder() или использовать вложенный Config с именованными полями.

4) Использование в Java DSL
Если хотите inline-предикат в коде (без фабрики), Java DSL позволяет:

.route("xfeature-inline", r -> r.p(exchange -> {
    List<String> values = exchange.getRequest().getHeaders().get("X-Feature");
    return values != null && values.stream().anyMatch(v -> v.equalsIgnoreCase("allowed1"));
}).uri("http://feature-service"))

Однако такой inline-предикат теряет преимущества конфигурируемости через YAML и переиспользуемости.


#Java #middle #Spring_Cloud_Gateway

Работа с конфигурационными объектами и AbstractRoutePredicateFactory — тонкости

Shortcut configuration vs. full Config binding

Если RoutePredicateFactory использует короткий синтаксис (например: MyPred=val1,val2), то AbstractRoutePredicateFactory поддерживает маппинг по shortcutFieldOrder() — список полей Config, которые будут заполнены по порядку.
Для явной структуры лучше использовать именованные свойства в YAML и обычный биндинг в Config.

Валидация конфигурации

Валидируйте конфиг в конструкторе предиката или в apply() — например, проверить, что список не пуст. Ошибки конфигурации лучше бросать на старте приложения, а не при первом запросе.
Сериализация/десериализация сложных типов
Для сложных типов (например, Duration, Pattern, InetAddress[]) используйте соответствующие конвертеры или храните строковые представления и парсите в Config.

Потокобезопасность

Predicate возвращаемый apply() должен быть потокобезопасным и не содержать mutable state, зависящего от запроса; храните precomputed структуры (например Pattern), а не парсьте каждый раз.

Логирование и мониторинг

Для сложных предикатов логируйте причины отказа (на низком уровне) либо метрики отказов, чтобы упростить отладку некорректного маршрутизации.


Примеры: несколько реальных сценариев и лучшие практики

Пример 1 — комбинация Host + Path + Method (YAML)

routes:
  - id: users-route
    uri: lb://user-service
    predicates:
      - Host=api.example.com
      - Path=/users/** 
      - Method=GET

Пояснение: типичный маршрут, дешёвые проверки (Host/Method/Path) — быстрый short-circuit.

Пример 2 — OR-логика через два маршрута (YAML)

routes:
  - id: mobile-route
    uri: lb://mobile-backend
    predicates:
      - Header=X-Client, ^mobile-.*
      - Path=/api/**
  - id: fallback-route
    uri: lb://web-backend
    predicates:
      - Path=/api/**

Пояснение: первый маршрут отведёт мобильный трафик на mobile-backend; второй поймает остальные запросы по тому же Path — это простой способ построить OR-поведение без кастомных предикатов.

Пример 3 — кастомный предикат с конфигом в YAML

predicates:
  - XFeature=allowedA,allowedB

(см. реализацию XFeatureRoutePredicateFactory выше).

#Java #middle #Spring_Cloud_Gateway