Spring Boot微服务间双向同步通信实现方案咨询

你的场景属于微服务间同步HTTP调用——M1发起请求后阻塞等待M2的响应，再基于响应结果执行业务逻辑。以下是Spring Boot中最常用的三种实现方案：

1. 使用RestTemplate（传统同步调用方案） #

RestTemplate是Spring原生的同步HTTP客户端，配置简单、上手快，适合基础的同步调用场景。

步骤： #

1. 在M1中配置RestTemplate Bean：

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        // 可自定义超时、拦截器等配置
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(5000); // 连接超时5秒
        factory.setReadTimeout(10000); // 读取超时10秒
        return new RestTemplate(factory);
    }
}

2. 在业务类中注入并调用M2接口：

@Service
public class M1BusinessService {
    private final RestTemplate restTemplate;

    // 构造注入（推荐）
    public M1BusinessService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public void executeBusiness() {
        // 若M2已注册到服务中心（如Nacos/Eureka），可直接用服务名替代IP:端口
        String m2ApiUrl = "http://m2-service/api/required-data";
        
        // 同步GET请求，接收响应（可替换为自定义DTO类型）
        try {
            String m2Response = restTemplate.getForObject(m2ApiUrl, String.class);
            
            // 基于M2响应执行业务逻辑
            if ("valid".equals(m2Response)) {
                // 业务代码执行
            }
        } catch (RestClientException e) {
            // 处理调用异常（超时、连接失败、M2返回错误码等）
            e.printStackTrace();
        }
    }
}

2. 使用OpenFeign（声明式优雅调用方案） #

OpenFeign是Spring Cloud提供的声明式HTTP客户端，基于接口定义调用规则，代码可读性强，还原生支持负载均衡、服务降级等微服务特性。

步骤： #

1. 添加OpenFeign依赖（Maven示例）：

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

2. 在M1启动类上开启Feign客户端：

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

3. 定义Feign客户端接口，映射M2的接口：

@FeignClient(name = "m2-service") // 指定M2的服务名
public interface M2Client {
    // 与M2的接口路径、请求方法完全匹配
    @GetMapping("/api/required-data")
    // 可直接返回自定义DTO对象
    String getRequiredData();
}

4. 在业务类中注入并调用：

@Service
public class M1BusinessService {
    private final M2Client m2Client;

    public M1BusinessService(M2Client m2Client) {
        this.m2Client = m2Client;
    }

    public void executeBusiness() {
        try {
            String m2Response = m2Client.getRequiredData();
            // 基于响应处理业务
        } catch (FeignException e) {
            // 处理Feign调用异常
        }
    }
}

可通过配置文件设置超时：

feign:
  client:
    config:
      m2-service:
        connect-timeout: 5000
        read-timeout: 10000

3. 使用WebClient（同步模式，适配响应式场景） #

WebClient是Spring 5+推出的响应式HTTP客户端，默认异步，可通过block()方法实现同步调用，适合已采用响应式编程的项目。

步骤： #

1. 配置WebClient Bean：

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
                .baseUrl("http://m2-service")
                .build();
    }
}

2. 在业务类中调用并阻塞等待响应：

@Service
public class M1BusinessService {
    private final WebClient webClient;

    public M1BusinessService(WebClient webClient) {
        this.webClient = webClient;
    }

    public void executeBusiness() {
        try {
            String m2Response = webClient.get()
                    .uri("/api/required-data")
                    .retrieve()
                    .bodyToMono(String.class)
                    .block(); // 阻塞等待响应，转为同步调用
            
            // 业务逻辑处理
        } catch (WebClientResponseException e) {
            // 处理调用异常
        }
    }
}

核心注意事项 #

• 服务发现依赖：若使用服务名调用M2，需确保M1、M2都注册到服务注册中心（如Nacos/Eureka），并在M1中引入对应服务发现依赖。
• 超时与异常处理：同步调用必须设置合理超时，避免线程长时间阻塞；同时要捕获调用异常，保证业务逻辑的健壮性。
• 负载均衡：OpenFeign和RestTemplate（配合服务发现）都原生支持负载均衡，无需额外配置即可实现多实例M2的调用分发。

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