How to Terminate Your Subscription on External Events with Spring's WebClient

Описание: Discover how to effectively manage subscriptions in your Spring application by replacing EmitterProcessor with Sinks for a clean shutdown.
---
This video is based on the question https://stackoverflow.com/q/65920864/ asked by the user 'David' ( https://stackoverflow.com/u/537738/ ) and on the answer https://stackoverflow.com/a/65934059/ provided by the user 'Simon Baslé' ( https://stackoverflow.com/u/1113486/ ) 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: Terminate subscription on external event

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.
---
Introduction

In today’s reactive applications, managing long-lived subscriptions can be tricky, especially when dealing with external events. A common scenario is to utilize long polling to maintain a connection with an external HTTP endpoint. With Spring's reactive WebClient, you might have implemented a clean shutdown process using an EmitterProcessor. However, as this component has been marked as deprecated, developers now face the challenge of transitioning to a new solution that ensures clean code and eliminates potential errors during application shutdowns.

In this post, we will explore how to effectively manage your subscriptions without being stuck on outdated libraries, specifically how to replace EmitterProcessor with Sinks in your long polling implementation.

Problem Statement

You may be using a long polling mechanism in your Spring application, where you utilize WebClient to continuously listen for messages from an external service. To gracefully shut down your subscriptions and avoid unpleasant stack traces during application termination, you may have used takeUntil() with an EmitterProcessor that is manually triggered when the application stops.

With EmitterProcessor being deprecated, the question arises: What should you do to replace it with a solution that secures your application’s longevity and stability?

Current Implementation

Here’s an outline of a simple implementation using EmitterProcessor:

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

While this implementation works, it’s time to shift away from EmitterProcessor to a more modern alternative.

Solution: Transitioning to Sinks

What are Sinks?

Sinks are designed as a developer-facing API that allows programmatically triggering reactive events. The key advantage of using Sinks is that they provide a way to present these events as Flux or Mono, which can seamlessly integrate into your entire reactive pipeline.

How to Replace EmitterProcessor with Sinks

To transition from using EmitterProcessor to Sinks, follow these steps:

Choose Your Sink Type:
Depending on whether you need to emit multiple events or a single one, you can choose between Sinks.Many, Sinks.One, or Sinks.Empty. For this scenario, Sinks.Many is typically the right choice.

Create a Sink Instance:
Instantiate a Sinks.Many instance in your class to manage emissions.

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

Modify the waitForMessages Method:
Update the method to utilize the asFlux() method of your Sinks.Many instance to convert it into a Flux.

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

Shutdown Logic:
Update your shutdown method to trigger the sink instead of the deprecated processor.

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

Key Benefits of Sinks

Non-blocking: Sinks are designed to work well in a reactive environment without blocking the execution flow.

Flexibility: They support multiple types of emissions, allowing you to adapt to the needs of your application with ease.

Future-proofing: By switching to Sinks, your application remains compliant with the latest versions of Project Reactor and ensures better long-term support.

Conclusion

Transitioning from EmitterProcessor to Sinks in your Spring application not only promotes cleaner code but also future-proofs your system against breaking changes in subsequent Project Reactor updates. By following the aforementioned steps, you'll maintain the reactive programming principles while enjoying a smooth and manageable shut down for your long-lived subscriptions.

Happy coding! With Sinks, you can bring your reactive applications to new heights without the worry of deprecated components holding you back.