A Mono<T> is a specialized Publisher<T> that emits at most one item and then (optionally) terminates with an onComplete signal or an onError signal. It offers only a subset of the operators that are available for a Flux, and some operators (notably those that combine the Mono with another Publisher) switch to a Flux. For … Read more
Reactive programming is a programming paradigm, but I wouldn’t call it new. It’s actually been around for a while. Just like object-oriented programming, functional programming, or procedural programming, reactive programming is another programming paradigm. Paradigm is defined by Reactive Manifesto Reactive Streams, on the other hand, is a specification. For Java programmers, Reactive Streams is … Read more
As explained in the Spring Boot reference documentation, Spring Boot will auto-configure a Spring MVC application if both MVC and WebFlux are available. There are several reasons for this: Spring MVC can’t run on Netty both infrastructure will compete for the same job (for example, serving static resources, the mappings, etc) mixing both runtime models … Read more
After the question, the present documentation does provide some clues about the concurrency model and the threads one could expect (but I still think that clearer/better descriptions of what happens under-the-scene from a multi-threading perspective would be highly appreciated by Spring newcomers). It discusses the difference between Spring MVC and Spring WebFlux (1-thread-per-request model vs. … Read more
The techniques that allow checking whether Flux/Mono is empty Using operators .switchIfEmpty/.defaultIfEmpty/Mono.repeatWhenEmpty Using mentioned operators you will be able to react to the case when Stream has been completed without emitting any elements. First of all, remember that operators such .map, .flatMap, .filter and many others will not be invoked at all if there no … Read more
Simply use verifyComplete(). If the Mono emits any data, it will fail the stepverifier as it doesn’t expect an onNext signal at this point.
map is for synchronous, non-blocking, 1-to-1 transformations flatMap is for asynchronous (non-blocking) 1-to-N transformations The difference is visible in the method signature: map takes a Function<T, U> and returns a Flux<U> flatMap takes a Function<T, Publisher<V>> and returns a Flux<V> That’s the major hint: you can pass a Function<T, Publisher<V>> to a map, but it … Read more
This is more or less similar to the situation in Spring MVC. In Spring MVC, you can use a AbstractRequestLoggingFilter filter and ContentCachingRequestWrapper and/or ContentCachingResponseWrapper. Many tradeoffs here: if you’d like to access servlet request attributes, you need to actually read and parse the request body logging the request body means buffering the request body, … Read more
It is a bit of an oversimplification but conceptually Reactor sources are either lazy or eager. More advanced ones, like an HTTP request, are expected to be lazily evaluated. On the other side the most simple ones like Mono.just or Flux.fromIterable are eager. By that, I mean that calling Mono.just(System.currentTimeMillis()) will immediately invoke the currentTimeMillis() … Read more
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 … Read more