public Predicate<ServerWebExchange> apply(Config config) {
    List<IpSubnetFilterRule> sources = config.getSources().stream()
        .map(IpSubnetFilterRule::new)
        .collect(Collectors.toList());
    
    return exchange -> {
        InetSocketAddress remoteAddress = exchange.getRequest()
            .getRemoteAddress();
        
        if (remoteAddress != null) {
            for (IpSubnetFilterRule source : sources) {
                if (source.matches(remoteAddress)) {
                    return true;
                }
            }
        }
        return false;
    };
}

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 80
        metadata:
          response-timeout: 3000
      
      - id: weight_low
        uri: https://weightlow.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 20
        metadata:
          response-timeout: 5000

predicates:
  - Method=GET,POST,OPTIONS
Внутренне преобразуется в проверку exchange.getRequest().getMethod().

predicates:
  - Path=/api/**
  - Method=GET
  - Header=X-API-Key,.*
  - Query=version,v2

@Component
public class OrRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<OrRoutePredicateFactory.Config> {
    
    public OrRoutePredicateFactory() {
        super(Config.class);
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            for (PredicateDefinition def : config.getPredicates()) {
                RoutePredicateFactory factory = findFactory(def);
                if (factory != null && factory.apply(convert(def)).test(exchange)) {
                    return true;
                }
            }
            return false;
        };
    }
    
    public static class Config {
        private List<PredicateDefinition> predicates = new ArrayList<>();
        // геттеры и сеттеры
    }
}

predicates:
  - name: Or
    args:
      predicates:
        - name: Path
          args:
            pattern: /api/v1/**
        - name: Path
          args:
            pattern: /legacy/api/**

public Predicate<ServerWebExchange> apply(Config config) {
    return exchange -> {
        // Инвертирование любого предиката
        return !delegatePredicate.test(exchange);
    };
}

@Component
public class JwtClaimRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<JwtClaimRoutePredicateFactory.Config> {
    
    private final JwtDecoder jwtDecoder;
    
    public JwtClaimRoutePredicateFactory(JwtDecoder jwtDecoder) {
        super(Config.class);
        this.jwtDecoder = jwtDecoder;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            // Извлечение JWT из заголовка
            String authHeader = exchange.getRequest()
                .getHeaders()
                .getFirst(HttpHeaders.AUTHORIZATION);
            
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                return false;
            }
            
            String token = authHeader.substring(7);
            
            try {
                // Декодирование и проверка claims
                Jwt jwt = jwtDecoder.decode(token);
                
                // Проверка конкретного claim
                String claimValue = jwt.getClaimAsString(config.getClaimName());
                
                if (claimValue == null) {
                    return false;
                }
                
                // Сопоставление с ожидаемым значением
                if (config.getPattern() != null) {
                    return claimValue.matches(config.getPattern());
                }
                
                return config.getExpectedValues()
                    .stream()
                    .anyMatch(expected -> expected.equals(claimValue));
                
            } catch (JwtException e) {
                return false;
            }
        };
    }
    
    // Конфигурационный класс
    public static class Config {
        private String claimName;
        private String pattern;
        private List<String> expectedValues = new ArrayList<>();
        
        // Геттеры и сеттеры
        public String getClaimName() {
            return claimName;
        }
        
        public void setClaimName(String claimName) {
            this.claimName = claimName;
        }
        
        public String getPattern() {
            return pattern;
        }
        
        public void setPattern(String pattern) {
            this.pattern = pattern;
        }
        
        public List<String> getExpectedValues() {
            return expectedValues;
        }
        
        public void setExpectedValues(List<String> expectedValues) {
            this.expectedValues = expectedValues;
        }
    }
    
    // Короткая форма конфигурации
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("claimName", "pattern");
    }
}

predicates:
  - name: JwtClaim
    args:
      claimName: roles
      expectedValues: admin,superuser

predicates:
  - JwtClaim=roles,admin|superuser

@Component
public class RateLimitPredicateFactory extends 
        AbstractRoutePredicateFactory<RateLimitPredicateFactory.Config> 
        implements ApplicationListener<EnvironmentChangeEvent> {
    
    private final RateLimiter rateLimiter;
    private final Map<String, Config> configCache = new ConcurrentHashMap<>();
    
    public RateLimitPredicateFactory(RateLimiter rateLimiter) {
        super(Config.class);
        this.rateLimiter = rateLimiter;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        // Кэширование конфигурации для производительности
        String cacheKey = config.getClientId() + ":" + config.getLimit();
        configCache.put(cacheKey, config);
        
        return exchange -> {
            Config cachedConfig = configCache.get(cacheKey);
            
            // Извлечение идентификатора клиента из запроса
            String clientId = extractClientId(exchange);
            
            if (clientId == null || !clientId.equals(cachedConfig.getClientId())) {
                return false;
            }
            
            // Проверка лимита
            return rateLimiter.tryAcquire(clientId, cachedConfig.getLimit());
        };
    }
    
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        // Очистка кэша при изменении конфигурации
        configCache.clear();
    }
    
    private String extractClientId(ServerWebExchange exchange) {
        // Логика извлечения clientId из запроса
        return exchange.getRequest().getHeaders()
            .getFirst("X-Client-Id");
    }
    
    public static class Config {
        private String clientId;
        private int limit;
        
        // Геттеры и сеттеры
    }
}

@Component
public class ExternalServicePredicateFactory extends 
        AbstractRoutePredicateFactory<ExternalServicePredicateFactory.Config> {
    
    private final WebClient webClient;
    
    @Override
    public AsyncPredicate<ServerWebExchange> applyAsync(Config config) {
        return exchange -> {
            // Асинхронная проверка через внешний сервис
            return webClient.post()
                .uri(config.getValidationUrl())
                .bodyValue(buildValidationRequest(exchange))
                .retrieve()
                .bodyToMono(ValidationResponse.class)
                .map(response -> response.isValid())
                .onErrorReturn(false); // При ошибке считаем предикат false
        };
    }
    
    public static class Config {
        private String validationUrl;
        private int timeoutMs = 1000;
        
        // Геттеры и сеттеры
    }
}

public Predicate<ServerWebExchange> apply(Config config) {
    LoadingCache<ServerWebExchange, Boolean> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(1, TimeUnit.MINUTES)
        .build(exchange -> computeExpensivePredicate(exchange, config));
    
    return exchange -> {
        try {
            return cache.get(exchange);
        } catch (Exception e) {
            return false;
        }
    };
}

predicates:
  - Method=GET              # Быстрая проверка
  - Path=/api/**            # Умеренная сложность
  - Query=token,.*          # Простая проверка параметра
  - JwtClaim=roles,admin   # Дорогая проверка JWT

Это позволяет отсеивать неподходящие запросы до выполнения дорогих операций.

public Predicate<ServerWebExchange> apply(Config config) {
    Counter matchCounter = meterRegistry.counter(
        "gateway.predicate.matches",
        "predicate", config.getName()
    );
    
    Counter totalCounter = meterRegistry.counter(
        "gateway.predicate.checks",
        "predicate", config.getName()
    );
    
    Timer timer = meterRegistry.timer(
        "gateway.predicate.duration",
        "predicate", config.getName()
    );
    
    return exchange -> {
        totalCounter.increment();
        
        return timer.record(() -> {
            boolean matches = internalTest(exchange, config);
            if (matches) {
                matchCounter.increment();
            }
            return matches;
        });
    };
}

Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // Этот код выполняется синхронно при построении цепочки
    long startTime = System.currentTimeMillis();
    
    // Возвращаем Mono, который описывает асинхронную операцию
    return chain.filter(exchange)
        .then(Mono.fromRunnable(() -> {
            // Этот код выполняется асинхронно ПОСЛЕ завершения цепочки
            long duration = System.currentTimeMillis() - startTime;
            log.info("Request processed in {} ms", duration);
        }));
}

public class DefaultGatewayFilterChain implements GatewayFilterChain {
    private final List<GatewayFilter> filters;
    private final int index;
    private final Publisher<Void> currentPublisher;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange) {
        return Mono.defer(() -> {
            if (this.index < filters.size()) {
                GatewayFilter filter = filters.get(this.index);
                DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(
                    this, this.index + 1);
                return filter.filter(exchange, chain);
            } else {
                return Mono.empty(); // Конец цепочки
            }
        });
    }
}

@Component
@Order(-1) // Выполняется ПЕРВЫМ
public class FirstGlobalFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("First global filter");
        return chain.filter(exchange);
    }
}

@Component 
@Order(0) // Выполняется ВТОРЫМ
public class SecondGlobalFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("Second global filter");
        return chain.filter(exchange);
    }
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    
    // Модификация запроса (PRE-фильтр)
    ServerHttpRequest mutatedRequest = request.mutate()
        .header(headerName, headerValue)
        .build();
    
    // Создание нового обмена с модифицированным запросом
    return chain.filter(exchange.mutate().request(mutatedRequest).build());
}

ServerHttpRequest mutated = exchange.getRequest().mutate()
    .headers(headers -> {
        headers.remove(headerName);
        // или headers.removeIf(key -> key.startsWith("X-Secret-"));
    })
    .build();

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    String path = exchange.getRequest().getURI().getRawPath();
    
    // Применение регулярного выражения
    String newPath = path.replaceAll(regexp, replacement);
    
    // Сохранение переменных из регулярного выражения
    Map<String, String> variables = extractVariables(path, regexp);
    exchange.getAttributes().put(URI_TEMPLATE_VARIABLES_ATTRIBUTE, variables);
    
    // Построение нового URI
    URI newUri = UriComponentsBuilder.fromUri(exchange.getRequest().getURI())
        .replacePath(newPath)
        .build(true)
        .toUri();
    
    ServerHttpRequest mutated = exchange.getRequest().mutate()
        .uri(newUri)
        .build();
    
    return chain.filter(exchange.mutate().request(mutated).build());
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // 1. Определение ключа для лимитирования
    return keyResolver.resolve(exchange)
        .switchIfEmpty(Mono.error(new IllegalStateException("Key not found")))
        .flatMap(key -> {
            // 2. Проверка лимита через Redis
            return rateLimiter.isAllowed(key, config.getReplenishRate(), 
                    config.getBurstCapacity(), config.getRequestedTokens())
                .flatMap(response -> {
                    // 3. Добавление заголовков с информацией о лимите
                    exchange.getResponse().getHeaders()
                        .add("X-RateLimit-Remaining", 
                            String.valueOf(response.getTokensLeft()));
                    exchange.getResponse().getHeaders()
                        .add("X-RateLimit-Replenish-Rate", 
                            String.valueOf(config.getReplenishRate()));
                    
                    if (response.isAllowed()) {
                        return chain.filter(exchange);
                    } else {
                        // 4. Отклонение запроса при превышении лимита
                        exchange.getResponse().setStatusCode(
                            HttpStatus.TOO_MANY_REQUESTS);
                        return exchange.getResponse().setComplete();
                    }
                });
        })
        .onErrorResume(Exception.class, e -> {
            // Обработка ошибок Redis
            log.warn("Rate limiter error", e);
            return chain.filter(exchange); // Разрешить запрос при ошибке
        });
}

-- Lua-скрипт, выполняемый атомарно в Redis
local tokens_key = KEYS[1]  -- ключ для хранения токенов
local timestamp_key = KEYS[2] -- ключ для метки времени

local rate = tonumber(ARGV[1]) -- replenishRate
local capacity = tonumber(ARGV[2]) -- burstCapacity
local now = tonumber(ARGV[3]) -- текущее время
local requested = tonumber(ARGV[4]) -- requestedTokens

local fill_time = capacity / rate
local ttl = math.floor(fill_time * 2)

local last_tokens = tonumber(redis.call("get", tokens_key))
if last_tokens == nil then
    last_tokens = capacity
end

local last_refreshed = tonumber(redis.call("get", timestamp_key))
if last_refreshed == nil then
    last_refreshed = 0
end

local delta = math.max(0, now - last_refreshed)
local filled_tokens = math.min(capacity, last_tokens + (delta * rate))

local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
if allowed then
    new_tokens = filled_tokens - requested
end

redis.call("setex", tokens_key, ttl, new_tokens)
redis.call("setex", timestamp_key, ttl, now)

return { allowed, new_tokens }

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    return retryOperator.apply(chain.filter(exchange))
        .onErrorResume(RetryExhaustedException.class, e -> {
            // Все попытки исчерпаны
            exchange.getResponse().setStatusCode(
                HttpStatus.SERVICE_UNAVAILABLE);
            return exchange.getResponse().setComplete();
        });
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    return circuitBreaker.run(
        chain.filter(exchange),
        throwable -> {
            // Fallback при открытом контуре или ошибке
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.SERVICE_UNAVAILABLE);
            response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
            
            byte[] fallbackBody = "{\"status\":\"unavailable\"}".getBytes();
            DataBuffer buffer = response.bufferFactory()
                .wrap(fallbackBody);
            
            return response.writeWith(Mono.just(buffer));
        }
    );
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // 1. Проверка Content-Type
    MediaType contentType = exchange.getRequest().getHeaders().getContentType();
    if (!config.getInClass().isInstance(contentType)) {
        return chain.filter(exchange);
    }
    
    // 2. Чтение тела запроса в память (ограничение по size)
    return DataBufferUtils.join(exchange.getRequest().getBody(), config.getMaxInMemorySize())
        .switchIfEmpty(Mono.just(EMPTY_BUFFER))
        .flatMap(dataBuffer -> {
            // 3. Десериализация
            return decode(dataBuffer, config.getInClass())
                .flatMap(decodedBody -> {
                    // 4. Трансформация
                    return config.getRewriteFunction()
                        .apply(exchange, decodedBody)
                        .flatMap(encodedBody -> {
                            // 5. Сериализация обратно
                            byte[] bytes = encode(encodedBody, config.getOutClass());
                            
                            // 6. Замена тела запроса
                            ServerHttpRequest mutated = exchange.getRequest().mutate()
                                .body(Flux.just(exchange.getResponse().bufferFactory()
                                    .wrap(bytes)))
                                .build();
                            
                            return chain.filter(
                                exchange.mutate().request(mutated).build()
                            );
                        });
                })
                .doFinally(signalType -> {
                    // 7. Освобождение буфера
                    DataBufferUtils.release(dataBuffer);
                });
        });
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // ПЕРВОЕ чтение
    return exchange.getRequest().getBody()
        .collectList()
        .flatMap(buffers -> {
            // ВТОРОЕ чтение (ОШИБКА!)
            return exchange.getRequest().getBody()
                .collectList()
                .flatMap(...);
        });
}

@Component
public class CacheRequestBodyFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // Фильтр, который кэширует тело для последующего использования
        return DataBufferUtils.join(exchange.getRequest().getBody())
            .defaultIfEmpty(EMPTY_BUFFER)
            .flatMap(dataBuffer -> {
                // Сохраняем кэшированное тело в атрибутах
                exchange.getAttributes().put(CACHED_REQUEST_BODY, dataBuffer);
                
                // Создаём новый запрос с кэшированным телом
                ServerHttpRequest mutated = exchange.getRequest().mutate()
                    .body(Flux.just(dataBuffer))
                    .build();
                
                return chain.filter(exchange.mutate().request(mutated).build());
            });
    }
    
    public static DataBuffer getCachedBody(ServerWebExchange exchange) {
        return exchange.getAttribute(CACHED_REQUEST_BODY);
    }
}

filters:
  - name: ModifyRequestBody
    args:
      inClass: String
      outClass: String
      rewriteFunction: "#{@myTransformer}"

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // Преобразование потока на лету
    Flux<DataBuffer> transformedBody = exchange.getRequest().getBody()
        .map(dataBuffer -> {
            // Трансформация каждого буфера
            byte[] bytes = new byte[dataBuffer.readableByteCount()];
            dataBuffer.read(bytes);
            
            // Пример: преобразование в верхний регистр
            String transformed = new String(bytes).toUpperCase();
            
            return exchange.getResponse().bufferFactory()
                .wrap(transformed.getBytes());
        });
    
    ServerHttpRequest mutated = exchange.getRequest().mutate()
        .body(transformedBody)
        .build();
    
    return chain.filter(exchange.mutate().request(mutated).build());
}

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

filters:
  - Logging=true,true,DEBUG

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

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