Spring Cloud Gateway中如何通过服务名同步调用微服务？

核心问题拆解 #

• 直接用服务名调用报Unknown Host Exception：未启用负载均衡客户端，无法将服务名解析为具体服务实例的网络地址。
• 添加@LoadBalanced后出现block()异常：Spring Cloud Gateway基于WebFlux响应式环境，RestTemplate的同步阻塞调用（如block()）会与响应式线程模型冲突，触发不支持的操作异常。

方案一：使用负载均衡版WebClient（推荐，适配响应式环境） #

Gateway本身是响应式架构，优先用WebClient实现服务调用，天然适配环境且支持负载均衡：

1. 配置带负载均衡的WebClient.Builder
   创建配置类注入负载均衡能力的WebClient构建器：

   @Configuration
   public class WebClientConfig {
       @Bean
       @LoadBalanced
       public WebClient.Builder loadBalancedWebClientBuilder() {
           return WebClient.builder();
       }
   }
   

2. 在AuthenticationFilter中注入并使用
   直接用服务名调用认证服务，全程采用响应式逻辑：

   @Component
   public class AuthenticationFilter implements GatewayFilter, Ordered {
       private final WebClient webClient;
   
       public AuthenticationFilter(WebClient.Builder webClientBuilder) {
           this.webClient = webClientBuilder.build();
       }
   
       @Override
       public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
           // 用服务名AUTHENTICATION-SERVICE直接调用
           return webClient.get()
                   .uri("http://AUTHENTICATION-SERVICE/api/auth/validate")
                   .retrieve()
                   .bodyToMono(AuthResponse.class)
                   .flatMap(authResponse -> {
                       // 处理认证通过逻辑，比如传递用户信息到下游服务
                       return chain.filter(exchange);
                   })
                   .onErrorResume(e -> {
                       // 认证失败返回401
                       exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                       return exchange.getResponse().setComplete();
                   });
       }
   
       @Override
       public int getOrder() {
           return -1; // 调整过滤器执行优先级，确保认证逻辑先执行
       }
   }
   

方案二：适配RestTemplate（不推荐，破坏响应式模型） #

如果必须使用RestTemplate，需规避响应式线程的阻塞冲突：

1. 配置负载均衡版RestTemplate
   保留@LoadBalanced注解，单独配置：

   @Configuration
   public class RestTemplateConfig {
       @Bean
       @LoadBalanced
       public RestTemplate loadBalancedRestTemplate() {
           return new RestTemplate();
       }
   }
   

2. 异步线程执行阻塞调用
   将RestTemplate的阻塞调用放到独立线程池，避免阻塞Gateway的响应式线程：

   @Component
   public class AuthenticationFilter implements GatewayFilter, Ordered {
       private final RestTemplate restTemplate;
       private final ExecutorService executorService = Executors.newFixedThreadPool(10);
   
       public AuthenticationFilter(RestTemplate restTemplate) {
           this.restTemplate = restTemplate;
       }
   
       @Override
       public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
           return Mono.fromCallable(() -> {
               // 在异步线程中执行服务名调用
               ResponseEntity<AuthResponse> response = restTemplate.getForEntity(
                       "http://AUTHENTICATION-SERVICE/api/auth/validate",
                       AuthResponse.class
               );
               return response.getBody();
           }).subscribeOn(Schedulers.fromExecutor(executorService))
             .flatMap(authResponse -> chain.filter(exchange))
             .onErrorResume(e -> {
                 exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                 return exchange.getResponse().setComplete();
             });
       }
   
       @Override
       public int getOrder() {
           return -1;
       }
   }
   

方案三：使用OpenFeign（适配同步调用，需异步包装） #

若偏好Feign的声明式调用，需适配响应式环境：

1. 添加Feign依赖
   在pom.xml中引入依赖：

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-openfeign</artifactId>
   </dependency>
   

2. 启用Feign客户端
   在Gateway启动类添加注解：

   @SpringBootApplication
   @EnableFeignClients
   public class CloudGatewayServiceApplication {
       public static void main(String[] args) {
           SpringApplication.run(CloudGatewayServiceApplication.class, args);
       }
   }
   

3. 定义Feign客户端接口

   @FeignClient(name = "AUTHENTICATION-SERVICE")
   public interface AuthServiceClient {
       @GetMapping("/api/auth/validate")
       AuthResponse validateToken();
   }
   

4. 异步执行Feign调用
   同样将同步的Feign调用放到独立线程池：

   @Component
   public class AuthenticationFilter implements GatewayFilter, Ordered {
       private final AuthServiceClient authServiceClient;
       private final ExecutorService executorService = Executors.newFixedThreadPool(10);
   
       public AuthenticationFilter(AuthServiceClient authServiceClient) {
           this.authServiceClient = authServiceClient;
       }
   
       @Override
       public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
           return Mono.fromCallable(authServiceClient::validateToken)
               .subscribeOn(Schedulers.fromExecutor(executorService))
               .flatMap(authResponse -> chain.filter(exchange))
               .onErrorResume(e -> {
                   exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                   return exchange.getResponse().setComplete();
               });
       }
   
       @Override
       public int getOrder() {
           return -1;
       }
   }
   

通用检查项 #

• 确保所有服务已注册到服务注册中心（如Eureka、Nacos），Gateway与其他服务能正常互相发现。
• 核对服务名与注册中心中的名称完全一致（注意大小写，默认服务名小写，若配置了大写需保持统一）。
• 确认依赖中包含spring-cloud-starter-loadbalancer（Gateway默认引入，若手动排除需重新添加）。

内容的提问来源于stack exchange，提问作者namalfernandolk