Spring MVC项目中如何用WebClient同时执行3个调用并处理结果？

当然可以！WebClient作为AsyncRestTemplate的官方替代方案，完全支持异步并发调用，而且在Spring MVC项目中使用起来非常顺畅。下面我会一步步给你展示具体的实现方式，包括核心代码、配置细节和注意事项。

1. 先配置WebClient #

首先需要在项目中配置WebClient的Bean，推荐通过配置类来创建，这样可以统一管理连接超时、响应超时等参数：

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient() {
        // 配置HttpClient，设置连接和响应超时
        HttpClient httpClient = HttpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                .responseTimeout(Duration.ofMillis(5000))
                .wiretap(true); // 可选，用于调试日志

        return WebClient.builder()
                .clientConnector(new ReactorClientHttpConnector(httpClient))
                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .build();
    }
}

2. 封装异步调用方法 #

创建一个服务类，把各个第三方接口的调用封装成返回Mono的方法——Mono是Reactor框架中表示单个异步结果的类型，多个Mono可以并发执行：

@Service
public class RemoteServiceClient {
    private final WebClient webClient;

    // 构造注入WebClient
    public RemoteServiceClient(WebClient webClient) {
        this.webClient = webClient;
    }

    // 调用第一个服务
    public Mono<UserData> fetchUserData(Long userId) {
        return webClient.get()
                .uri("https://api.example.com/users/{id}", userId)
                .retrieve()
                .bodyToMono(UserData.class)
                .onErrorResume(ex -> {
                    // 容错处理：调用失败时返回默认值或自定义逻辑
                    log.error("获取用户数据失败", ex);
                    return Mono.just(new UserData());
                });
    }

    // 调用第二个服务
    public Mono<OrderData> fetchOrderData(Long userId) {
        return webClient.get()
                .uri("https://api.example.com/orders/user/{id}", userId)
                .retrieve()
                .bodyToMono(OrderData.class)
                .onErrorReturn(new OrderData()); // 简单容错：失败返回空对象
    }

    // 调用第三个服务
    public Mono<WalletData> fetchWalletData(Long userId) {
        return webClient.get()
                .uri("https://api.example.com/wallets/user/{id}", userId)
                .retrieve()
                .bodyToMono(WalletData.class);
    }
}

3. 并发调用并合并结果 #

在Spring MVC的控制器中，我们可以通过Mono.zip()方法将三个异步调用合并，这个方法会等待所有Mono都完成后，返回一个包含所有结果的元组（Tuple），然后我们就可以统一处理这些结果了。

这里有两种实现方式，推荐第二种非阻塞的方式：

方式一：同步等待（简单但会阻塞线程） #

如果你的业务场景对线程阻塞不敏感，可以直接用block()方法等待所有调用完成：

@RestController
@RequestMapping("/user")
public class UserController {
    private final RemoteServiceClient remoteServiceClient;

    public UserController(RemoteServiceClient remoteServiceClient) {
        this.remoteServiceClient = remoteServiceClient;
    }

    @GetMapping("/{id}/summary")
    public ResponseEntity<UserSummary> getUserSummary(@PathVariable Long id) {
        // 同时发起三个异步调用
        Mono<UserData> userMono = remoteServiceClient.fetchUserData(id);
        Mono<OrderData> orderMono = remoteServiceClient.fetchOrderData(id);
        Mono<WalletData> walletMono = remoteServiceClient.fetchWalletData(id);

        // 等待所有调用完成，获取合并后的结果
        Tuple3<UserData, OrderData, WalletData> results = Mono.zip(userMono, orderMono, walletMono)
                .block(Duration.ofSeconds(10)); // 设置超时时间，避免无限等待

        // 统一处理结果，组装返回对象
        UserSummary summary = new UserSummary();
        summary.setUserData(results.getT1());
        summary.setOrderData(results.getT2());
        summary.setWalletData(results.getT3());

        return ResponseEntity.ok(summary);
    }
}

方式二：非阻塞异步返回（推荐） #

为了避免阻塞Tomcat的工作线程，我们可以让控制器方法返回CompletableFuture，Spring MVC会自动处理异步逻辑：

@GetMapping("/{id}/summary-async")
public CompletableFuture<ResponseEntity<UserSummary>> getUserSummaryAsync(@PathVariable Long id) {
    Mono<UserData> userMono = remoteServiceClient.fetchUserData(id);
    Mono<OrderData> orderMono = remoteServiceClient.fetchOrderData(id);
    Mono<WalletData> walletMono = remoteServiceClient.fetchWalletData(id);

    // 合并结果并转换为CompletableFuture
    return Mono.zip(userMono, orderMono, walletMono)
            .map(results -> {
                UserSummary summary = new UserSummary();
                summary.setUserData(results.getT1());
                summary.setOrderData(results.getT2());
                summary.setWalletData(results.getT3());
                return ResponseEntity.ok(summary);
            })
            .toFuture();
}

关键注意事项 #

• 容错处理：一定要给每个Mono添加错误处理逻辑（比如onErrorResume、onErrorReturn），否则只要有一个调用失败，整个合并后的Mono就会直接抛出异常，导致所有结果都无法返回。
• 线程池配置：WebClient默认使用Reactor的线程池，不会占用Tomcat的工作线程，但如果你的并发量很高，建议自定义WebClient的线程池参数，避免资源耗尽。
• 超时设置：无论是WebClient的连接/响应超时，还是block()方法的超时，都必须明确设置，防止请求无限挂起。

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