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 flatMapManyIn 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 thenManyAll 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