How to return Mono from Mono on error?

Question

Let's say i have the following chain:

public Mono<B> someMethod( Object arg ) {
  Mono<A> monoA = Mono.just( arg ).flatMap( adapter1::doSomething );
  // success chain
  return monoA.map( B::buildSuccessResponse );
}

But in case of error i need to return different type of B, let's say, B.buildErrorResponse( a ). Any onError / doOnError methods can return only original Mono type (A), but not the one I need to return (B). How to return different Mono type in case of error?

score 2 · Answer 1 · answered Apr 22 '18 at 13:01

2

public Mono<B> someMethod(Object arg) {
    return Mono.just(arg)
            .flatMap(adapter1::doSomething)
            .onErrorResume(throwable -> throwable instanceof Exception,
                           throwable -> Mono.just(B.buildErrorResponse(throwable)))
            .map(B::buildSuccessResponse);
}

onErrorResume will catch the error signal if it was thrown in upstream and will replace all that stream (the upstream) with a new stream: Mono.just(B.buildErrorResponse(throwable)).

Side note about someMethod logic:

In case of an error, this method will signal a next signal which indicates error signal: B.buildErrorResponse(throwable). It sounds like a bad idea because who will use someMethod must understand if the next signal he received from upstream (someMthod) is next or error signal by if-condition. Instead, let someMethod return the actual error signal and the user will react to that error as he wants by recognizing the error in, for example, onErrorResume.
I have the same argument for B::buildSuccessResponse.
The following code can be replaced: Mono.just(arg).flatMap(adapter1::doSomething) with adapter1.doSomething(arg).

All in all, the final code will be refactored to:

public Mono<B> someMethod(Object arg) {
    return adapter1.doSomething(arg).
}

answered Apr 22 '18 at 13:01

Stav Alfi

13,139
23
99
171

1

`onErrorResume` returns a `Mono` with the same type as the stream, so your code wouldn't even compile. You need to move that part to the end. Is there any particular reason why you check the type of the throwable? – a better oliver May 04 '18 at 10:07
1. The OP wrote: `in case of error i need to return different type of B, let's say, B.buildErrorResponse( a )` ==> `B.buildErrorResponse( a ) instance of B` , `B.buildSuccessResponse( a ) instance of B`. (This is what he returned in the question..). 2. I checked the type of the throwable to show to OP how to use `onErrorResume`. – Stav Alfi May 04 '18 at 11:40
1 doesn't explain the non-working code. As for 2: There is a variant of `onErrorResume` that only expects single argument. I see no reason to use another one. – a better oliver May 04 '18 at 11:45
I don't see a reason to replacea stream with unchecked exceptions which a new stream. If I get `NullpointerException`, I would go back to the code. – Stav Alfi May 04 '18 at 11:54
The `onErrorResume` part cannot work at this position because it has to return a `Mono`. Maybe you want to ignore other errors but the OP doesn't. – a better oliver May 04 '18 at 12:02
The return type is `Mono`. – Stav Alfi May 04 '18 at 13:01
I suggest to consult the documentation. – a better oliver May 08 '18 at 06:35

Bas Kuis · Answer 2 · 2018-08-07T14:13:15.557

The methods you might want to check out are: onErrorResume(Throwable, Mapper) or onErrorResume(Predicate)

For example your code could look something like this:

public Mono<B> someMethod( Object arg ) {
  Mono monoA = Mono.just( arg ).flatMap( adapter1::doSomething );
  return monoA.onErrorResume({ Throwable e ->
      return B::buildSuccessResponse
  });
}

In this case the onErrorResume would handle any error emitted from adapter1::doSomething. Keep in mind that when an error is emitted - no further 'map', 'flatMap' or any other method is invoked on subsequent Monos since an error will be passed down instead of the expected object.

You could then simply chain it all to look like:

public Mono<B> someMethod( Object arg ) {
  return Mono.just( arg ).flatMap( adapter1::doSomething ).onErrorResume({ Throwable e ->
      return B::buildSuccessResponse
  });
}

Keep in mind that all method that start with 'do' like 'doOnError' will execute the closure provided without modifying the 'emitted' object.

score 1 · Answer 3 · answered Jun 03 '20 at 16:47

public Mono<B> someMethod( Object arg ) {
  Mono<A> monoA = Mono.just( arg ).flatMap( adapter1::doSomething );

  return monoA
   .map( B::buildSuccessResponse )
   .onErrorResume({ Throwable e ->
      return  Mono.just(B.buildSuccessResponse(e));
   }); // if there is no error, `onErrorResume` is effectively doing nothing
}

Below is a simple test which you can use to test the behaviour

    public static void main(String[] args) {
        Mono.just(1)
                .doOnNext(x -> {
                    throw new RuntimeException("some error from previous operation");
                }) //comment this out if you want to simulate successful response
                .map(String::valueOf)
                .onErrorResume(e -> Mono.just("error response"))
                .subscribe(System.out::println);
    }

How to return Mono from Mono on error?

3 Answers3