I don't understand the use and the difference between then, thenEmpty
, thenMany
and flatMapMany
on Flux
or Mono
in spring webflux.
flatMap. flatMapMany. Java Streams. Accepts Function SE -> SE which takes a synchronous element and returns a single synchronous element. Returns a Java Stream.
Project Reactor is the implementation of Reactive Streams specification. Reactor provides two types: Mono: implements Publisher and returns 0 or 1 elements. Flux: implements Publisher and returns N elements.
3. Handling Backpressure in Spring WebFlux. Spring WebFlux provides an asynchronous non-blocking flow of reactive streams. The responsible for backpressure within Spring WebFlux is the Project Reactor. It internally uses Flux functionalities to apply the mechanisms to control the events produced by the emitter.
A Flux object represents a reactive sequence of 0.. N items, while a Mono object represents a single-value-or-empty (0..1) result. This distinction carries a bit of semantic information into the type, indicating the rough cardinality of the asynchronous processing.
flatMap
vs flatMapMany
In functional programming, flatMap
returns the same type than the type that bear the method, so for Mono<T>
, flatMap
returns a Mono
. Which means that only one element can be emitted by the inner Publisher
(or that it is truncated). We enforced that by having Mono#flatMap
take a Function<T, Mono<R>>
.
As a consequence, we needed an alternative for more arbitrary Publisher
that could emit more than one element. Hence Mono#flatMapMany(Function<T, Publisher<R>>)
which returns a Flux<R>
.
TL;DR: Mono#flatMap
is for asynchronous but 1-to-1 transformation of the element in the source Mono
, Mono#flatMapMany
is for 1-to-N asynchronous transformation (like Flux#flatMap).
then
, thenEmpty
and thenMany
All the thenXXX
methods on Mono
have one semantic in common: they ignore the source onNext
signals and react on completion signals (onComplete
and onError
), continuing the sequence at this point with various options. As a consequence, this can change the generic type of the returned Mono
:
then
will just replay the source terminal signal, resulting in a Mono<Void>
to indicate that this never signals any onNext
.thenEmpty
not only returns a Mono<Void>
, but it takes a Mono<Void>
as a parameter. It represents a concatenation of the source completion signal then the second, empty Mono completion signal. In other words, it completes when A then B have both completed sequentially, and doesn't emit data.thenMany
waits for the source to complete then plays all the signals from its Publisher<R>
parameter, resulting in a Flux<R>
that will "pause" until the source completes, then emit the many elements from the provided publisher before replaying its completion signal as well.If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With