当flatMap返回一个空的Mono时如何调用switchIfEmpty？

Question

My title sounds confusing so let me explain with some imperative pseudo code for what I'm trying to do

Mono<Void> func() {
  Mono<MyThing> myThing = getMyThing();
  if myThing is not empty:
    return doSomething();
  else:
    return doSomethingElse();
}

Here's where I'm stuck when I try to do this reactively:

Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
  Mono<MyThing> myThing = getMyThing();
  return myThing
    .flatMap(thing -> {
      Mono<Void> somethingMono = doSomething();
      return somethingMono;
    })
    .switchIfEmpty(Mono.defer(() -> {
      Mono<Void> somethingElseMono = doSomethingElse();
      return somethingElseMono;
    });
}

This works fine when myThing is empty. It skips the .flatMap() and executes the .switchIfEmpty() statement.

However, when myThing is not empty, it executes .flatMap() which is what I want. But the flatMap returns a Mono<Void> which triggers the subsequent .switchIfEmpty() method.

I tried swapping the position of the .flatMap() and .switchIfEmpty() but that doesn't work either because the .switchIfEmpty() returns a Mono<Void> whereas the .flatMap() expects a Mono<MyThing> .

This seems like a common pattern so wondering what's the right way to do this.

Answer 1

There's a few ways you could do this. Since you're using Mono<Void> as the return type, you could do something like:

getMyThing()
        .delayUntil(thing -> doSomething())
        .switchIfEmpty(doSomethingElse().cast(String.class))
        .then()

...but that's not the neatest or clearest IMHO. It's a bit more verbose, but I'd be tempted to map to an optional as so:

getMyThing().map(Optional::of).defaultIfEmpty(Optional.empty())
        .flatMap(thing -> thing.isPresent() ? doSomething() : doSomethingElse())
        .then()

If you need to do this often, you might consider a transformation utility method:

public static <T> Mono<Optional<T>> optional(Mono<T> mono) {
    return mono.map(Optional::of).defaultIfEmpty(Optional.empty());
}

...which would then enable you to just do getMyThing().transform(Utils::optional) rather than do the explicit mapping / default each time.