Mono vs Flux in Reactive Stream
Reactive ProgrammingProject ReactorReactive StreamsReactive Programming Problem Overview
As per the documentation:
> Flux is a stream which can emit 0..N elements:
Flux<String> fl = Flux.just("a", "b", "c");
> Mono is a stream of 0..1 elements:
Mono<String> mn = Mono.just("hello");
And as both are the implementations of the Publisher interface in the reactive stream.
Can't we use only Flux in most of the cases as it also can emit 0..1, thus satisfying the conditions of a Mono?
Or there are some specific conditions when only Mono needs to be used and Flux can not handle the operations? Please suggest.
Reactive Programming Solutions
Solution 1 - Reactive Programming
In many cases, you are doing some computation or calling a service and you expect exactly one result (or maybe zero or one result), and not a collection that contains possibly multiple results. In such cases, it's more convenient to have a Mono
.
Compare it to "regular" Java: you would not use List
as the return type of any method that can return zero or one result. You would use Optional
instead, which makes it immediately clear that you do not expect more than one result.
Solution 2 - Reactive Programming
Flux is equivalent to RxJava Observable is capable of emitting
- zero or more item (streams of many elements)
- and then OPTIONALLY , completing OR failing
Mono can only emit one item at the most (streams one element)
Relations:
- If you concatente two Monos you will get a Flux
- You can call single() on Flux
to return a Mono
Solution 3 - Reactive Programming
From the docs here
This distinction carries a bit of semantic information into the type, indicating the rough cardinality of the asynchronous processing. For instance, an HTTP request produces only one response, so there is not much sense in doing a count operation. Expressing the result of such an HTTP call as a Mono
Solution 4 - Reactive Programming
Simply as the Mono is used for handling zero or one result, while the Flux is used to handle zero to many results, possibly even infinite results. And both two in common behave in a purely asynchronous and fully non-blocking.
Solution 5 - Reactive Programming
I think it is good practice to use Mono in cases where we know we can only get one result. In this way, we make it known to other developers working on the same thing that the result can be 0 or 1.
We are following that approach on all our projects.
Here is one good tutorial on Reactive Streams and the uses of Mono and Flux -> Reactive programming in Java.