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: 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() и могут использоваться для реализации динамического поведения.

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

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

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

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

.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")
)

.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")
)

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

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}'"

<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"

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

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')

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

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

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