如何避免Mono.zip中单个Mono抛异常导致所有Mono立即终止？

Absolutely! You can definitely work around the default fail-fast behavior of Mono.zip() where a single failing Mono immediately cancels all others. Your idea of using error-handling operators like doOnError is on the right track, but you’ll need to pair it with operators that let the failing Mono complete normally instead of emitting an error signal. Here’s how to make it work:

Why the default behavior happens #

By design, Mono.zip() follows a fail-fast strategy: as soon as any of the source Monos emits an error, it cancels all other Monos and propagates the error immediately. To prevent this, we need to ensure each Mono never emits an error—instead, we catch the error, handle it, and let the Mono finish with a valid (or fallback) value.

Step-by-step solution #

1. Use doOnError for side-effect error handling: This operator lets you log errors, send alerts, or run any other cleanup logic when an exception occurs. It doesn’t change the Mono’s signal (error will still be emitted), so we need more to fix the cancelation.
2. Add onErrorResume or onErrorReturn to recover from errors: These operators replace the error signal with a normal completion (either a fallback value or another Mono). This ensures the wrapped Mono always finishes successfully, so Mono.zip() will wait for all of them to complete.

Example code #

Here’s a concrete example of wrapping each Mono to make your zip operation resilient:

// Assume these are your original Monos, some of which might throw
Mono<String> riskyMono1 = someService.fetchData1();
Mono<Integer> riskyMono2 = someService.fetchData2();
Mono<Boolean> riskyMono3 = someService.fetchData3();

// Wrap each Mono with error handling to ensure normal completion
Mono<String> safeMono1 = riskyMono1
    .doOnError(e -> System.err.println("Mono1 failed: " + e.getMessage())) // Log error
    .onErrorResume(e -> Mono.just("fallback-value-1")); // Fallback to valid value

Mono<Integer> safeMono2 = riskyMono2
    .doOnError(e -> {
        // Custom error handling (e.g., send alert)
        alertService.sendFailureAlert("Mono2 failed", e);
    })
    .onErrorReturn(-1); // Fallback to default integer

Mono<Boolean> safeMono3 = riskyMono3
    .doOnError(e -> log.error("Mono3 execution failed", e)) // Log with logger
    .onErrorResume(e -> Mono.just(false)); // Fallback to boolean value

// Now zip will wait for ALL safe Monos to complete, even if some failed
Mono.zip(safeMono1, safeMono2, safeMono3)
    .subscribe(resultTuple -> {
        String res1 = resultTuple.getT1();
        Integer res2 = resultTuple.getT2();
        Boolean res3 = resultTuple.getT3();
        
        // You can check fallback values to identify which Monos failed
        if (res1.equals("fallback-value-1")) {
            // Handle Mono1's failure case
        }
        // ... handle other results
    });

Important notes #

• Don’t rely on doOnError alone: As mentioned, doOnError only runs side effects—it doesn’t stop the error from being emitted. If you use only doOnError, Mono.zip() will still cancel other Monos when an error occurs.
• Choose the right recovery operator: Use onErrorReturn if you have a simple fallback value, or onErrorResume if you need to compute a fallback dynamically (e.g., fetch from a cache).
• Track failures if needed: If you need to know exactly which Monos failed, you can use fallback values that are distinct from valid results (like the -1 or false in the example) or wrap results in a custom class that includes a success/failure flag.

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