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

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

Раздел 6. Коллекции в Java

Глава 2. List — списки

Практика В проекте «Библиотека» заменить массив книг на ArrayList. Реализовать методы: добавить книгу, найти по названию, удалить по индексу

Убедитесь, что ваш проект готов, и вспомните ключевые возможности ArrayList:

Динамический размер (растёт автоматически)
Доступ по индексу O(1)
Добавление в конец O(1) в среднем
Удаление O(n) (сдвиг элементов)
Поиск indexOf O(n)


Откройте проект «Библиотека»: Запустите IntelliJ IDEA и откройте проект LibraryProject.

Проверьте структуру: У вас должен быть класс Book с полями title, author, year, конструктором и методом printDetails(). Класс Library с массивом книг и методом addBook.


Замена массива на ArrayList

Замените поле массива:
Откройте файл Library.java.
Удалите объявление массива Book[] books и переменную bookCount.
Вместо этого объявите приватное поле:
private List<Book> books = new ArrayList<>();
Это будет наш основной список книг.

Инициализация:
Убедитесь, что books инициализируется в конструкторе (если не сделали при объявлении).
Можно также создать отдельный конструктор Library(), где books = new ArrayList<>(); — на ваш выбор.


Реализация метода добавления книги

Создайте или обновите метод addBook(Book book):
Метод должен быть публичным и принимать объект Book.
Используйте метод add() из ArrayList для добавления книги в конец списка.
Добавьте вывод сообщения: "Книга [title] успешно добавлена".
(Опционально) Проверьте, что книга не null перед добавлением.


Реализация метода поиска книги по названию

Создайте метод findBookByTitle(String title):
Метод должен возвращать объект Book или null, если не найден.
Переберите весь список с помощью цикла for или for-each.
Для каждой книги сравните её title с искомым (используйте equals(), учитывая регистр или используйте equalsIgnoreCase() для нечувствительности к регистру).
Если совпадение найдено — верните эту книгу.
Если цикл завершился — верните null.
Добавьте вывод: "Книга найдена: [title]" или "Книга не найдена".

Альтернативный способ (по желанию):
Используйте метод indexOf() с временным объектом-заглушкой, у которого title совпадает с искомым (переопределите equals() в Book, если нужно).


Реализация метода удаления книги по индексу

Создайте метод removeBookByIndex(int index):
Метод должен возвращать boolean: true — если удаление прошло успешно, false — если индекс неверный.
Проверьте, что индекс в допустимом диапазоне: >= 0 и < books.size().
Если индекс неверный — выведите сообщение "Неверный индекс" и верните false.
Если индекс корректный — используйте метод remove(index) из ArrayList.
Сохраните удаленную книгу (Book removedBook = books.remove(index);) и выведите сообщение "Книга удалена: [title удаленной книги]".
Верните true.


#Java #для_новичков #beginner #List #ArrayList #LinkedList #Практика

Обновление Main для тестирования
Теперь протестируем новые методы в классе Main.

Создайте объект Library и добавьте книги:
Создайте несколько объектов Book (минимум 4-5).
Добавьте их в библиотеку через addBook().

Протестируйте поиск:
Вызовите findBookByTitle() с существующим и несуществующим названием.
Если книга найдена — вызовите printDetails() на возвращенном объекте.

Протестируйте удаление:
Выведите текущий размер списка (books.size()).
Удалите книгу по валидному индексу (например, 1).
Удалите по невалидному индексу (например, -1 или больше size).
Выведите размер после удаления.

Дополнительно: Добавьте метод printAllBooks() в Library, который перебирает весь список и вызывает printDetails() для каждой книги — используйте его для проверки состояния библиотеки.


Тестирование и отладка

Запустите проект:
Run 'Main.main()' — наблюдайте за сообщениями в консоли.

Проверьте поведение:
Добавление: Список растёт, нет ограничений по размеру.
Поиск: Находит по точному совпадению.
Удаление: Корректно удаляет и сдвигает элементы.

Отладка:
Установите breakpoint в методе removeBookByIndex и findBookByTitle.
Шагайте по коду (F8) и смотрите, как меняется размер списка и содержимое.


Полезные советы для новичков

Импорты: Не забудьте import java.util.ArrayList; и import java.util.List;
Generics: List<Book> books — всегда используйте generics.
Проверка на null: В addBook: if (book == null) return;
Регистр в поиске: equalsIgnoreCase() для нечувствительности к регистру.
Вывод размера: books.size() вместо books.length (это массив!).
Удаление: remove(index) возвращает удаленный элемент — удобно для сообщений.


Практическое задание

Задача 1: Добавьте в Library метод getBookCount(), возвращающий books.size().
Задача 2: Реализуйте метод removeBookByTitle(String title), который находит книгу по названию и удаляет её (используйте цикл или indexOf + remove).
Задача 3: Добавьте метод printAllBooks(), который выводит все книги с номерами (индекс + 1).


#Java #для_новичков #beginner #List #ArrayList #LinkedList #Практика

Конфигурация маршрутов в 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

Глава 6. Итераторы

Интерфейс Iterator — фундаментальный механизм обхода коллекций

Итераторы представляют собой один из наиболее элегантных и мощных паттернов проектирования в программировании, обеспечивающий унифицированный способ последовательного доступа к элементам коллекций без раскрытия их внутреннего устройства. В Java интерфейс Iterator<E> служит стандартизированным контрактом для обхода любых коллекций, независимо от их внутренней реализации. Этот механизм не только упрощает код, но и обеспечивает абстракцию, позволяя алгоритмам работать с различными структурами данных единообразно.


Философия итераторов

Итераторы воплощают принцип единственной ответственности — отделяют логику обхода элементов от самих коллекций.

Это разделение позволяет:
Изменять внутреннее устройство коллекций, не затрагивая клиентский код
Обеспечивать единый интерфейс для работы с разнородными структурами данных
Реализовывать ленивую инициализацию и отложенную загрузку элементов
Поддерживать безопасное удаление элементов во время обхода


Архитектура интерфейса Iterator

Интерфейс Iterator<E> определен в пакете java.util и содержит три фундаментальных метода:

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

Каждый из этих методов играет критически важную роль в процессе итерации и имеет свою собственную семантику и особенности реализации.


Метод hasNext(): Проверка наличия следующего элемента

Метод hasNext() выполняет предикативную функцию — определяет, существуют ли еще элементы для обхода в коллекции. Этот метод является безопасным и идемпотентным, что означает возможность его многократного вызова без побочных эффектов.

Семантика и поведение
Детерминированность: Метод всегда возвращает однозначный результат — true или false, без промежуточных состояний.
Отсутствие побочных эффектов: Вызов hasNext() не модифицирует состояние итератора и не перемещает указатель текущей позиции.
Инвариантность: Результат метода зависит исключительно от внутреннего состояния итератора и коллекции на момент вызова.

Внутренние механизмы реализации

Для коллекций с известным размером (ArrayList, HashSet)
В коллекциях, где количество элементов известно заранее или может быть быстро вычислено, реализация hasNext() обычно сводится к простому сравнению:

// Концептуальная реализация для ArrayList
public boolean hasNext() {
    return currentPosition < size;
}

Оптимизации:
Кэширование размера коллекции для избежания повторных вычислений
Флаги для отслеживания структурных изменений коллекции
Минимальные проверки для максимизации производительности

Для ленивых или потоковых коллекций

В случаях, когда элементы генерируются на лету или загружаются отложенно, реализация hasNext() может быть более сложной:
Проверка наличия данных в буфере
Запрос к внешнему источнику данных
Ожидание генерации следующего элемента
Обработка возможных исключений

Для структур данных со сложной навигацией (TreeMap, LinkedList)

В итераторах для сложных структур реализация hasNext() требует анализа внутреннего состояния:
Проверка достижения листовых узлов в деревьях
Анализ ссылок в связных списках
Учет особенностей обхода для конкретного алгоритма (in-order, pre-order, post-order)

Особенности производительности

Временная сложность: В большинстве реализаций hasNext() выполняется за O(1) время, так как требует только проверки условий без обхода структур.
Потребление памяти: Метод не создает новых объектов и использует минимальное количество временных переменных.
Thread-safety: В стандартных реализациях hasNext() не является потокобезопасным методом. Concurrent модификации коллекции могут привести к неконсистентным результатам.

Паттерны использования

Классический цикл обхода

Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    // Обработка элемента
}

Защита от пустых коллекций

if (iterator.hasNext()) {
    // Коллекция не пуста, можно начинать обработку
    processFirstElement(iterator.next());
}

#Java #для_новичков #beginner #Iterator

Предварительная проверка перед сложными операциями

while (iterator.hasNext()) {
    if (shouldProcessNext()) {
        processElement(iterator.next());
    } else {
        break; // Ранний выход из цикла
    }
}

Метод next(): Получение следующего элемента

Метод next() является основным двигателем итерации — он возвращает следующий элемент коллекции и продвигает внутренний указатель позиции. Этот метод сочетает в себе функциональность доступа к данным и изменения состояния итератора.

Семантика и поведение

Изменение состояния: Каждый успешный вызов next() модифицирует внутреннее состояние итератора, перемещая указатель текущей позиции.
Исключительные ситуации: Если элементов больше нет, метод выбрасывает NoSuchElementException.
Порядок обхода: Возвращает элементы в порядке, определенном конкретной реализацией итератора для данной коллекции.

Внутренние механизмы реализации

Для массивных структур (ArrayList, ArrayDeque)
Для коллекций на основе массивов реализация next() обычно прямолинейна:

// Концептуальная реализация для ArrayList
public E next() {
    if (!hasNext()) {
        throw new NoSuchElementException();
    }
    lastReturned = currentPosition;
    return elementData[currentPosition++];
}

Ключевые аспекты:
Сохранение индекса последнего возвращенного элемента для поддержки remove()
Постинкрементация указателя текущей позиции
Прямой доступ к массиву через индекс

Для связных структур (LinkedList, TreeSet)

В итераторах для связных структур реализация более сложна:

// Концептуальная реализация для LinkedList
public E next() {
    if (!hasNext()) {
        throw new NoSuchElementException();
    }
    lastReturned = current;
    current = current.next; // Переход к следующему узлу
    return lastReturned.item;
}

Особенности:
Навигация по ссылкам между узлами
Поддержка различных направлений обхода
Учет особенностей структуры (например, балансировки деревьев)

Для fail-fast итераторов

Многие реализации итераторов в Java используют механизм fail-fast, который включает дополнительную проверку:

public E next() {
    checkForComodification(); // Проверка структурных изменений
    if (!hasNext()) {
        throw new NoSuchElementException();
    }
    // ... основная логика
}

Механизм проверки: Сравнение внутреннего счетчика модификаций итератора с счетчиком коллекции.

Обработка исключительных ситуаций

NoSuchElementException
Это исключение сигнализирует о попытке получить элемент за пределами коллекции. Оно является unchecked исключением и обычно указывает на логическую ошибку в коде.

Типичные причины:
Неправильное условие завершения цикла
Параллельные модификации коллекции
Ошибки в логике работы с итератором

ConcurrentModificationException
В fail-fast итераторах возникает при обнаружении структурных изменений коллекции во время итерации.

Стратегии предотвращения:
Использование synchronized коллекций
Применение копий коллекций для итерации
Использование специальных concurrent итераторов

Особенности производительности
Временная сложность: Зависит от структуры данных:

ArrayList: O(1)
LinkedList: O(1) для перехода между узлами (но O(n) для поиска начальной позиции)
TreeSet: O(1) amortized для сбалансированных деревьев
Память: Может создавать временные объекты или сохранять ссылки для поддержки операций удаления.
Потокобезопасность: Стандартные реализации не являются потокобезопасными.

Паттерны использования

Последовательная обработка всех элементов

while (iterator.hasNext()) {
    Element element = iterator.next();
    processElement(element);
}

Ограниченная обработка

for (int i = 0; i < limit && iterator.hasNext(); i++) {
    Element element = iterator.next();
    processElement(element);
}

Пропуск элементов

// Пропустить первые N элементов
for (int i = 0; i < skipCount && iterator.hasNext(); i++) {
    iterator.next();
}

// Обработать оставшиеся
while (iterator.hasNext()) {
    processElement(iterator.next());
}

#Java #для_новичков #beginner #Iterator

Метод remove(): Удаление текущего элемента

Метод remove() представляет собой одну из наиболее сложных и тонких операций в интерфейсе итератора. Он позволяет удалить из коллекции элемент, который был последним возвращен вызовом next(). Этот метод обеспечивает безопасное удаление во время итерации, что невозможно при использовании методов удаления самой коллекции.

Семантика и поведение

Состояние зависимости: Может быть вызван только после успешного вызова next() и только один раз для каждого вызова next().
Исключительные ситуации: Выбрасывает IllegalStateException при нарушении условий вызова.
Структурное изменение: Модифицирует как коллекцию, так и внутреннее состояние итератора.

Внутренние механизмы реализации

Общий алгоритм работы

// Концептуальный шаблон реализации
public void remove() {
    if (lastReturned == null) {
        throw new IllegalStateException();
    }
    checkForComodification();
    
    // Удаление элемента из коллекции
    collection.removeElement(lastReturned);
    
    // Корректировка состояния итератора
    adjustIteratorState();
    
    lastReturned = null;
    expectedModCount = modCount;
}

Для ArrayList

Реализация remove() в ArrayListIterator требует особой обработки из-за массива как базовой структуры:

public void remove() {
    if (lastReturned < 0) {
        throw new IllegalStateException();
    }
    checkForComodification();
    
    try {
        // Удаление элемента из ArrayList
        ArrayList.this.remove(lastReturned);
        
        // Корректировка позиции итератора
        cursor = lastReturned;
        lastReturned = -1;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Специфические аспекты:
Сдвиг элементов массива после удаления
Корректировка текущей позиции итератора
Обновление счетчиков модификаций

Для LinkedList

В LinkedListIterator реализация использует преимущества связной структуры:

public void remove() {
    checkForComodification();
    if (lastReturned == null) {
        throw new IllegalStateException();
    }
    
    Node<E> lastNext = lastReturned.next;
    // Удаление узла из связного списка
    unlink(lastReturned);
    
    if (next == lastReturned) {
        next = lastNext;
    } else {
        nextIndex--;
    }
    lastReturned = null;
    expectedModCount++;
}

Преимущества связной структуры:
Более эффективное удаление (O(1) после нахождения узла)
Простая корректировка ссылок
Естественная поддержка удаления во время итерации

Условия корректного вызова

Необходимые предварительные условия
Предшествующий успешный вызов next(): Должен быть получен элемент для удаления
Отсутствие промежуточных вызовов remove(): Для каждого next() может быть только один remove()
Совместимость состояния: Итератор и коллекция должны быть синхронизированы

Типичные ошибки и исключения

IllegalStateException:
Вызов remove() до первого вызова next()
Повторный вызов remove() для того же элемента
Вызов remove() после структурных изменений коллекции другими средствами

ConcurrentModificationException:
Параллельные модификации коллекции из других потоков
Использование методов удаления самой коллекции во время итерации

Особенности производительности

Временная сложность: Зависит от базовой коллекции:
ArrayList: O(n) из-за необходимости сдвига элементов
LinkedList: O(1) после нахождения узла
HashSet: O(1) в среднем случае
Потокобезопасность: Стандартные реализации не являются потокобезопасными.
Побочные эффекты: Изменяет размер коллекции и инвалидирует некоторые операции.


#Java #для_новичков #beginner #Iterator

Паттерны использования

Безопасное удаление во время итерации

Iterator<Item> iterator = collection.iterator();
while (iterator.hasNext()) {
    Item item = iterator.next();
    if (shouldRemove(item)) {
        iterator.remove(); // Безопасное удаление
    }
}

Фильтрация коллекции

public static <T> void filter(Collection<T> collection, Predicate<T> predicate) {
    Iterator<T> iterator = collection.iterator();
    while (iterator.hasNext()) {
        if (!predicate.test(iterator.next())) {
            iterator.remove();
        }
    }
}

Очистка коллекции по условию

// Удалить все null элементы
iterator = list.iterator();
while (iterator.hasNext()) {
    if (iterator.next() == null) {
        iterator.remove();
    }
}

Сравнение с альтернативными подходами

Iterator.remove() vs Collection.remove()

Преимущества Iterator.remove():
Безопасность во время итерации
Корректное обновление состояния итератора
Оптимизированная реализация для конкретной структуры данных

Недостатки Collection.remove():
Риск ConcurrentModificationException
Необходимость повторного поиска элемента
Потенциальная неэффективность

Iterator.remove() vs Copy-and-Filter

Копирование с фильтрацией:

List<Item> filtered = new ArrayList<>();
for (Item item : original) {
    if (!shouldRemove(item)) {
        filtered.add(item);
    }
}
original = filtered;

Сравнение:
Копирование: Проще, но требует дополнительной памяти
Итератор: Эффективнее по памяти, но требует осторожности
Интеграция трех методов: Полный цикл итерации
Согласованная работа hasNext(), next() и remove()

Эти три метода образуют единую систему, где каждый играет свою роль в процессе итерации:

public class SafeIterationExample {
    public static void processAndRemove(Collection<Data> collection) {
        Iterator<Data> iterator = collection.iterator();
        
        // Фаза 1: Подготовка и проверка
        while (iterator.hasNext()) {
            
            // Фаза 2: Получение элемента
            Data data = iterator.next();
            
            // Фаза 3: Обработка и возможное удаление
            if (data.isProcessed()) {
                iterator.remove(); // Безопасное удаление
            } else {
                data.process();
            }
        }
    }
}

#Java #для_новичков #beginner #Iterator

Паттерны управления состоянием

Управление состоянием lastReturned

Правильное управление полем lastReturned критически важно для корректной работы remove():
Установка: В next() после успешного получения элемента
Сброс: В remove() после успешного удаления
Проверка: Перед вызовом remove() для валидации состояния

Синхронизация счетчиков модификаций

Для fail-fast итераторов необходимо поддерживать синхронизацию:
expectedModCount: Сохраняется при создании итератора
modCount: Обновляется при структурных изменениях коллекции
Сравнение: При каждой операции проверяется равенство счетчиков

Расширенные сценарии использования

Итерация с пропуском элементов

public static <T> void skipAndProcess(Iterator<T> iterator, int skipCount) {
    // Пропуск первых N элементов
    for (int i = 0; i < skipCount && iterator.hasNext(); i++) {
        iterator.next();
    }
    
    // Обработка оставшихся с возможным удалением
    while (iterator.hasNext()) {
        T element = iterator.next();
        if (shouldProcess(element)) {
            processElement(element);
        } else {
            iterator.remove();
        }
    }
}

Пакетная обработка с удалением

public static <T> List<T> batchProcessAndRemove(
        Collection<T> collection, 
        Predicate<T> removalCondition,
        int batchSize) {
    
    List<T> removed = new ArrayList<>();
    Iterator<T> iterator = collection.iterator();
    int processed = 0;
    
    while (iterator.hasNext() && processed < batchSize) {
        T element = iterator.next();
        if (removalCondition.test(element)) {
            removed.add(element);
            iterator.remove();
        }
        processed++;
    }
    
    return removed;
}

Best Practices и рекомендации

Эффективное использование итераторов

Используйте enhanced for-loop когда возможно:

for (Element element : collection) {
    // Автоматическое управление итератором
}

Избегайте ненужных вызовов hasNext():

// Неоптимально:
while (iterator.hasNext()) {
    if (condition) {
        process(iterator.next());
    }
}

// Оптимально:
while (iterator.hasNext()) {
    Element element = iterator.next();
    if (condition) {
        process(element);
    }
}

Безопасность в многопоточных сценариях

Синхронизируйте доступ к итераторам:

synchronized(collection) {
    Iterator<E> iterator = collection.iterator();
    while (iterator.hasNext()) {
        // Обработка
    }
}

Используйте потокобезопасные альтернативы:

// CopyOnWriteArrayList для read-heavy workloads
// ConcurrentHashMap для concurrent модификаций
// Collections.synchronized для оберток

Избегайте структурных изменений во время итерации:

// Собирайте элементы для удаления отдельно
List<Element> toRemove = new ArrayList<>();
for (Element element : collection) {
    if (shouldRemove(element)) {
        toRemove.add(element);
    }
}
collection.removeAll(toRemove);

#Java #для_новичков #beginner #Iterator

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