Скачать или смотреть Solve the Performance Issue: Wait for a Flux inside a Flux in Spring Webflux

Learn how to efficiently handle nested Flux operations in Spring Webflux without blocking to improve performance.
---
This video is based on the question https://stackoverflow.com/q/64740474/ asked by the user 'Josemar Henrique' ( https://stackoverflow.com/u/9639250/ ) and on the answer https://stackoverflow.com/a/64741096/ provided by the user 'Toerktumlare' ( https://stackoverflow.com/u/1840146/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Spring Webflux Wait for a Flux inside a Flux

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Solving the Performance Issue: Wait for a Flux Inside a Flux in Spring Webflux

In today's world of reactive programming, developers often encounter challenges when dealing with nested asynchronous operations. One common scenario is working with Flux in Spring Webflux, especially when you are dealing with data from multiple sources such as ReactiveMongoDB and a WebClient.

The Problem Explained

Imagine you are using a Flux to retrieve a list of items from a MongoDB database. For each item , you need to fetch associated details from a WebClient. The approach you're currently using involves blocking the thread for each WebClient call, which can severely impact performance, especially when scaling up the number of items. When you use a blocking operation, your application waits for the details before proceeding, leading to inefficient use of resources, as other operations cannot execute in parallel.

Here’s a simplified version of the current approach leading to the performance bottleneck:

[[See Video to Reveal this Text or Code Snippet]]

In this code, the use of .block() waits for the WebClient to return the data before continuing, which is not an optimal way to leverage the reactive paradigm of Spring Webflux.

The Solution: Non-blocking Approach Using thenReturn

To address this challenge, we can rearrange our code to remove blocking calls and use a more efficient method employing thenReturn. This approach allows for all calls to be made in a non-blocking way and only collects the results when they’re ready.

The Improved Code

Here's how you can implement the non-blocking pattern:

[[See Video to Reveal this Text or Code Snippet]]

Explanation of the Improved Code:

flatMap:

We start by retrieving all items from the MongoDB collection using flatMap, which allows for asynchronous processing of each item.

WebClient Call:

For each planetaVO, we call recuperarFilmesParticipados, which returns another Flux of items from the WebClient.

collectList():

This method collects all items emitted by the WebClient into a List.

doOnNext:

Utilizing doOnNext, we set the fetched films directly into the planetaVO, without blocking the execution.

thenReturn():

Finally, thenReturn(planetaVO) provides a Mono that emits the original planetaVO, ensuring that we can work with it later in our processing chain without blocking.

Conclusion

By optimizing the approach to wait for the results of a Flux within another Flux, you can significantly enhance the performance of your Spring Webflux application. This non-blocking pattern allows for better resource management and faster response times, leveraging the strengths of reactive programming.

In conclusion, remember to avoid blocking wherever possible when working with reactive streams. This not only improves performance but preserves the non-blocking nature of your application. Happy coding!