如何避免Mono.zip()在单个Mono抛出异常时取消操作？

要避免单个Mono出错导致整个Mono.zip流程终止，核心思路是给每个Mono添加异常兜底处理，让它们在出错时仍能返回一个有效结果（而非触发错误信号），这样Mono.zip就能正常收集所有Mono的输出。

方法1：简单兜底——返回默认值/错误提示 #

使用onErrorReturn为每个可能出错的Mono指定异常发生时的返回值，这样Mono会正常完成而非抛出错误。

修改后的代码示例：

Mono<String> mono1 = Mono.just("Result 1");
// 给出错的Mono添加异常兜底，返回错误提示文本
Mono<String> mono2 = Mono.error(new RuntimeException("Error in mono2"))
                         .onErrorReturn("Error: mono2执行失败");
Mono<String> mono3 = Mono.just("Result 3");

return Mono.zip(mono1, mono2, mono3)
           .map(tuple -> {
               String result1 = tuple.getT1();
               String result2 = tuple.getT2();
               String result3 = tuple.getT3();
               return result1 + ", " + result2 + ", " + result3;
           });

这种方式适合简单场景，缺点是无法区分返回值是正常结果还是错误兜底内容。

方法2：严谨兜底——用自定义Result类区分成功/失败 #

如果需要明确区分每个Mono的执行状态（成功/失败），可以定义一个通用的Result类，包装结果数据和错误信息。

1. 定义Result类 #

class Result<T> {
    private boolean success;
    private T data;
    private String errorMessage;

    // 静态工厂方法，简化实例创建
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.success = true;
        result.data = data;
        return result;
    }

    public static <T> Result<T> failure(String errorMessage) {
        Result<T> result = new Result<>();
        result.success = false;
        result.errorMessage = errorMessage;
        return result;
    }

    // Getter方法
    public boolean isSuccess() { return success; }
    public T getData() { return data; }
    public String getErrorMessage() { return errorMessage; }
}

2. 修改Mono的异常处理 #

用onErrorResume捕获异常并返回失败的Result实例，成功时则返回包装后的成功Result：

Mono<Result<String>> mono1 = Mono.just("Result 1")
                                 .map(Result::success)
                                 .onErrorResume(e -> Mono.just(Result.failure(e.getMessage())));

Mono<Result<String>> mono2 = Mono.error(new RuntimeException("Error in mono2"))
                                 .map(Result::success)
                                 .onErrorResume(e -> Mono.just(Result.failure(e.getMessage())));

Mono<Result<String>> mono3 = Mono.just("Result 3")
                                 .map(Result::success)
                                 .onErrorResume(e -> Mono.just(Result.failure(e.getMessage())));

return Mono.zip(mono1, mono2, mono3)
           .map(tuple -> {
               Result<String> res1 = tuple.getT1();
               Result<String> res2 = tuple.getT2();
               Result<String> res3 = tuple.getT3();

               StringBuilder sb = new StringBuilder();
               // 逐个处理每个Mono的结果
               appendResult(sb, res1);
               sb.append(", ");
               appendResult(sb, res2);
               sb.append(", ");
               appendResult(sb, res3);

               return sb.toString();
           });

// 辅助方法：根据Result状态拼接文本
private void appendResult(StringBuilder sb, Result<String> result) {
    if (result.isSuccess()) {
        sb.append(result.getData());
    } else {
        sb.append("失败: ").append(result.getErrorMessage());
    }
}

这种方式能清晰区分每个Mono的执行状态，便于后续做更复杂的业务处理。

关键原理说明 #

Mono.zip的特性是：只要任一Mono发出错误信号，整个zip操作就会立即终止并传递该错误。通过onErrorReturn或onErrorResume捕获单个Mono的异常，将错误信号转换为正常的完成信号（返回兜底值），就能让Mono.zip顺利收集所有Mono的输出，不会因单个失败而中断。

内容的提问来源于stack exchange，提问作者tatiana isabel hoyos