Quick insight on Reactive Web-sockets in Spring-5

Reading Time: 4 minutes

Are you tired of traditional request-response communication in your web applications? Do you want to take a step forward and implement real-time data streaming between the client and server? If so, then Reactive Web-Sockets are the answer! In this blog post, we will explore the basics of Reactive Web-Sockets in Spring-5. We’ll cover everything from their architecture to code examples that showcase how they work. So buckle up and get ready to learn about this exciting new technology!

What are Reactive Web-sockets?

WebSockets are a new technology that allows for full-duplex, bi-directional communication between a client and server. They are an alternative to the traditional HTTP request/response model, and can be used to build real-time applications such as chat clients, online gaming, and more.

The Reactive WebSockets library is built on top of the existing Java WebSocket API (JSR 356), and adds several features that make it easier to use in a reactive way:

Backpressure: The library automatically applies backpressure when necessary to ensure smooth communication between client and server. This helps to avoid overloading either side with too much data, which can lead to lag or dropped connections.

Flexible Threading Model: You can choose whether to run your application on a single thread or multiple threads. The library will take care of ensuring that messages are delivered safely across threads.

Non-Blocking I/O: All operations are non-blocking, so your application can continue processing messages even if one connection is slow or stalls.

Reactive Streams Integration: The library integrates with the Reactive Streams specification (JSR 373), so you can use all of the operators provided by that specification to manipulate your data streams

What is Spring-5?

Spring-5 is a Java-based framework that provides support for the development of web applications. It is designed to make developing web applications easier by providing a set of standard components that can be reused. Spring-5 also supports the use of annotations to simplify configuration.

Let’s Setting up WebSocket in Spring-5 :

WebSocket is a protocol that provides full-duplex communication channels over a single TCP connection. It is designed for real-time communication between web browsers and web servers, and can be used for developing applications such as online chat, stock ticker, whiteboard, collaborative editing, multiplayer gaming, etc. 

Spring 5 has introduced a new reactive programming model for web applications. In this model, the WebSocket protocol can be used to create asynchronous and event-based applications. This article will show you how to set up WebSocket in Spring 5. 

First, you need to add the following dependency to your project: 


now you need to configure the WebSocket endpoint in your Spring configuration file:

Sending and receiving messages using WebSocketHandler

Assuming that we have a basic understanding of WebSockets, let’s see how we can use them in a Spring application. We will be using the same example from the previous section, where we had a simple chat application.

We will be using the WebSocketHandler class to send and receive messages. The first thing we need to do is add the required dependencies:



Once we have these dependencies in our project, we can create a WebSocketConfig class to configure our WebSocket endpoint:


@EnableWebSocketMessageBroker // This annotation enables message broker 


public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

 public void registerStompEndpoints(StompEndpointRegistry registry) { //   

This method registers STOMP endpoints with the given registry 

        registry.addEndpoint("/ws").withSockJS(); // The endpoint is "/ws" 

and it uses SockJS by default


    @Override // This method configures message broker options  		  

(i.e destination prefixes, user destination separator)  ,...etc 

    public void configureMessageBroker(MessageBrokerRegistry registry) {

Configuring the Stomp Protocol

When it comes to configuring the Stomp protocol, there are a few key things that you need to keep in mind. First and foremost, you need to make sure that your server is configured to support the Stomp protocol. This can usually be done by adding a dependency on the stomp-websocket module. Secondly, you need to configure a message broker to provide support for the STOMP protocol. The most popular message brokers used with STOMP are ActiveMQ and RabbitMQ. Lastly, you need to configure your client to connect to the STOMP broker using the appropriate URL.

Handling messages using Message Handlers

In Spring, you can handle messages using Message Handlers. Message handlers are components that receive messages from a message source, do some processing, and then return a response. In Spring, there are two types of message handlers:

1. SimpleMessageHandler: A simple message handler just returns the response back to the caller.

2. AsyncMessageHandler: An async message handler returns a Future object back to the caller, which can be used to retrieve the response asynchronously.

To use a message handler, you first need to create a @Bean of type Message Handler . Then, you can inject this bean into your controller or service class.

	public MessageHandler messageHandler() {

	    return new SimpleMessageHandler();


Closing connections with Disconnect Event

When a WebSocket connection is no longer needed, it should be closed in order to free up resources. TheDisconnectEvent is used to close a WebSocket connection gracefully. This event is fired when the close() method is called on a WebSocket session, or when the server detects that the client has disconnected.

Conclusion :

In conclusion, understanding and implementing reactive web-sockets in Spring 5 is an important step towards creating a more efficient and user-friendly web application. With the help of this technology, developers can create applications that are fully reactive and therefor provide a better experience for end users. By leveraging the features of Spring 5, developers can take advantage of this new technology to build powerful web applications with less effort. We hope this article has been helpful in getting you started on your journey with reactive web-sockets in Spring 5.


Written by 

Gaurav srivastav is a Software Consultant working in java domain.