Spring Boot中WebClient异步调用后等待全部响应的最优方案咨询

你完全没必要用无限循环检查响应状态——Spring WebFlux基于Reactor框架，本身就提供了专门处理多异步任务等待与结果合并的操作符，完全贴合异步非阻塞的设计理念，比轮询高效得多。

核心方案：根据需求选择对应的组合操作符 #

1. 固定数量的异步调用，需要合并所有结果 #

如果你的外部调用数量是固定的（比如3个），用Mono.zip()最直接——它会等待所有传入的Mono都完成，然后把结果打包成一个Tuple，你可以从中提取每个调用的结果进行后续处理。

示例代码：

@Service
public class ExternalServiceHandler {
    private final WebClient webClient;

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

    public Mono<CombinedData> handleMultiServiceCalls() {
        // 发起三个独立的异步调用
        Mono<UserData> userDataMono = webClient.get()
                .uri("/api/users/123")
                .retrieve()
                .bodyToMono(UserData.class);

        Mono<OrderData> orderDataMono = webClient.get()
                .uri("/api/users/123/orders")
                .retrieve()
                .bodyToMono(OrderData.class);

        Mono<PaymentData> paymentDataMono = webClient.get()
                .uri("/api/users/123/payments")
                .retrieve()
                .bodyToMono(PaymentData.class);

        // 等待所有调用完成，合并结果
        return Mono.zip(userDataMono, orderDataMono, paymentDataMono)
                .map(tuple -> {
                    // 从Tuple中提取每个调用的结果
                    UserData user = tuple.getT1();
                    OrderData orders = tuple.getT2();
                    PaymentData payments = tuple.getT3();
                    // 组合成自定义业务对象
                    return new CombinedData(user, orders, payments);
                })
                // 执行所有调用完成后的后续任务
                .flatMap(this::processCombinedData);
    }

    // 后续业务处理示例
    private Mono<CombinedData> processCombinedData(CombinedData data) {
        // 比如保存到数据库、计算统计值等
        return Mono.just(data);
    }

    // 自定义数据类示例
    record UserData(Long id, String name) {}
    record OrderData(List<Long> orderIds) {}
    record PaymentData(Double totalAmount) {}
    record CombinedData(UserData user, OrderData orders, PaymentData payments) {}
}

2. 处理错误：允许部分调用失败，等待所有任务结束 #

如果担心某个外部调用失败导致整个流程中断，可以用Mono.zipDelayError()——它会等待所有Mono执行完成（包括失败的），再统一处理错误或缺失的结果。

示例：

return Mono.zipDelayError(userDataMono, orderDataMono, paymentDataMono)
        .map(tuple -> {
            // 对可能失败的调用设置默认值
            UserData user = Optional.ofNullable(tuple.getT1()).orElse(new UserData(-1L, "unknown"));
            OrderData orders = Optional.ofNullable(tuple.getT2()).orElse(new OrderData(Collections.emptyList()));
            PaymentData payments = Optional.ofNullable(tuple.getT3()).orElse(new PaymentData(0.0));
            return new CombinedData(user, orders, payments);
        })
        .onErrorResume(throwable -> {
            // 捕获所有错误，返回降级结果
            return Mono.just(new CombinedData(
                    new UserData(-1L, "error"),
                    new OrderData(Collections.emptyList()),
                    new PaymentData(0.0)
            ));
        });

3. 不确定数量的异步调用 #

如果你的外部调用数量是动态的（比如从数据库读取要调用的接口列表），可以把所有Mono放到集合里，用Flux来批量执行并等待全部完成：

public Mono<String> handleDynamicCalls(List<String> serviceUris) {
    // 把URI列表转成Mono集合
    List<Mono<String>> serviceCalls = serviceUris.stream()
            .map(uri -> webClient.get()
                    .uri(uri)
                    .retrieve()
                    .bodyToMono(String.class))
            .collect(Collectors.toList());

    // 并行执行所有调用，收集结果到List
    return Flux.fromIterable(serviceCalls)
            .flatMap(Function.identity()) // 触发所有Mono执行
            .collectList() // 等待所有调用完成，获取结果列表
            .map(results -> String.join("|", results)) // 合并结果
            .flatMap(this::processMergedResult); // 后续任务
}

private Mono<String> processMergedResult(String merged) {
    // 处理合并后的结果
    return Mono.just(merged.toUpperCase());
}

为什么轮询是糟糕的选择？ #

• 违背WebFlux的异步非阻塞设计：轮询会占用线程资源，导致线程空转，浪费性能。
• 代码冗余且易出错：需要手动管理每个调用的状态，还要处理线程安全问题。
• 缺乏原生错误处理：轮询模式下很难优雅地处理调用失败、超时等异常情况。

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