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);
    }
}

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

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

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // Блокирующий вызов в реактивном контексте
    String result = blockingService.call(); // ОПАСНО!
    
    return chain.filter(exchange);
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // Обёртка блокирующего вызова в отдельном пуле потоков
    return Mono.fromCallable(() -> blockingService.call())
        .subscribeOn(Schedulers.boundedElastic()) // Выделенный пул для блокирующих операций
        .flatMap(result -> {
            // Использование результата
            return chain.filter(exchange);
        });
}

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    return DataBufferUtils.join(exchange.getRequest().getBody())
        .flatMap(dataBuffer -> {
            try {
                // Работа с буфером
                return processBuffer(dataBuffer)
                    .flatMap(result -> chain.filter(exchange));
            } finally {
                // Обязательное освобождение
                DataBufferUtils.release(dataBuffer);
            }
        });
}

@Component
public class MetricsGlobalFilter implements GlobalFilter {
    
    private final MeterRegistry meterRegistry;
    private final Map<String, Timer> timerCache = new ConcurrentHashMap<>();
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        long startTime = System.nanoTime();
        String routeId = exchange.getAttribute(ROUTE_ATTRIBUTE_ID);
        
        return chain.filter(exchange)
            .doOnSuccess(v -> recordSuccess(routeId, startTime))
            .doOnError(e -> recordError(routeId, startTime, e));
    }
    
    private void recordSuccess(String routeId, long startTime) {
        long duration = System.nanoTime() - startTime;
        
        Timer timer = timerCache.computeIfAbsent(routeId, id ->
            Timer.builder("gateway.request.duration")
                .tag("route", id)
                .tag("status", "success")
                .register(meterRegistry));
        
        timer.record(duration, TimeUnit.NANOSECONDS);
    }
}

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class Task171225 {
    public static void main(String[] args) {
        Map<String, Integer> failFast = new HashMap<>();
        Map<String, Integer> failSafe = new ConcurrentHashMap<>();
        
        failFast.put("A", 1);
        failFast.put("B", 2);
        failSafe.put("A", 1);
        failSafe.put("B", 2);
        
        try {
            for (String key : failFast.keySet()) {
                System.out.print(key + " ");
                if (key.equals("A")) failFast.remove("B");
            }
        } catch (Exception e) {
            System.out.print("FFex ");
        }
        
        try {
            for (String key : failSafe.keySet()) {
                System.out.print(key + " ");
                if (key.equals("A")) failSafe.remove("B");
            }
        } catch (Exception e) {
            System.out.print("FSex ");
        }
        
        System.out.print(failFast.size() + " ");
        System.out.print(failSafe.size());
    }
}

import java.util.*;

public class Task181225 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
        
        try {
            list.forEach(item -> {
                System.out.print(item + " ");
                if (item.equals("b")) {
                    list.add("d");
                }
            });
        } catch (Exception e) {
            System.out.print("Exception ");
        }
        
        System.out.println(list.size());
    }
}