#reactive programming

한동안 마무리 지어야 하는 일때문에 정신이 없다가 이제서야 정리를 할 시간이 오게 되었다..

이 포스트에서는 Angular가 무엇인지 모르는 분들을 위해 Angular를 설명하는 내용을 채울까 한다.

Angular 2 그리고 웹 프론트엔드 (1/2) - 현재 글

Angular 2 그리고 웹 프론트엔드 (2/2)

Angular Forms in 2026: Implementing State-First Reactivity for Scalable Applications

A deep dive into the industry shift from RxJS-heavy Reactive Forms to Signal-based state-first management, exploring the performance gains and architectural impacts highlighted in recent industry analysis.

In modern web applications, real-time communication plays a crucial role, especially in scenarios like live notifications, updates on dashboards, or chat applications. While technologies like WebSockets have been a go-to solution, Server-Sent Events (SSE) is an alternative that offers simplicity and scalability. In this blog, we will dive into the purpose of SSE, how Spring WebFlux facilitates its implementation, and how it compares to WebSocket programming in terms of functionality and advantages. Covalense Digital’s Test Automation Framework (CTAF), a modern application with real-time notifications and shared data, utilises Spring Webflux's reactive programming technique.

Issues Identified

After the data is sent from the HTTP server to the client (browsers), if there is an update in the data, only on client refresh will the page initiate the request to get the latest data from the server.

The client might not be aware if there is an update to perform refresh or polling.

The application on the HTTP server may not reply if the client clicks the refresh button many times. Failure to address this can cause the program and server to fail.

Occasionally these refreshes can also cause the closing of existing sessions and re-initiation of new sessions which can lead to data loss, which can leave a bad user experience.

Data inconsistency displayed to multiple clients from the same application is not live data update to various clients.

To get live updates, WebSocket programming is necessary. This requires a unique application setup on both client and server due to the multiple protocols used.

What is Server-Sent Events (SSE)?

Server-Sent Events are a standard for pushing real-time updates from a server to a client over a single HTTP connection. It allows the server to send events to the browser without the browser having to make repeated requests, providing a more efficient communication channel than traditional polling.

Key Characteristics of SSE:

Unidirectional Communication: SSE is designed for real-time data from server to client. This one-way channel is ideal for scenarios where the server initiates the updates, like live news feeds or stock ticker updates.

HTTP-Based: SSE leverages the standard HTTP protocol, ensuring compatibility with existing web infrastructure. This eliminates the need for specialized servers or protocols, making SSE easy to implement.

Automatic Reconnection: SSE automatically handles dropped connections. If a client loses connection with the server, it will automatically attempt to reconnect, ensuring a continuous flow of real-time updates.

Lightweight: Compared to other real-time technologies like WebSockets, SSE has a lower overhead due to its simplicity. This makes it more efficient in terms of resource usage, especially for applications with a large number of concurrent connections.

Why Use SSE?

Efficient Communication: SSE minimizes overhead by using a single, long-lived HTTP connection. This reduces the need for repeated handshakes and headers, making data transfer more efficient, especially for frequent updates.

Simpler than WebSockets: SSE offers a simpler implementation compared to WebSockets. It doesn't require a full-duplex connection, making it easier to set up and manage, particularly for scenarios where the server is the primary data source.

Automatic Reconnection: SSE automatically handles dropped connections. If a client loses connection, it will automatically attempt to reconnect. This ensures a continuous flow of real-time updates without manual intervention.

Ideal for Read-Only Data Streams: SSE is well-suited for applications where the server primarily pushes data to the client. Examples include live news feeds, stock ticker updates, and monitoring dashboards

Spring WebFlux and Server-Sent Events

Spring WebFlux is a reactive programming framework that is designed for building non-blocking and event-driven applications. It supports SSE out of the box, making it a powerful tool for creating real-time applications. Here's how WebFlux fits into the picture:

How Spring WebFlux Enables SSE

Reactive Streams: Spring WebFlux leverages Project Reactor to manage the flow of data asynchronously. This fits perfectly with the nature of SSE, which requires data to be pushed to the client without blocking or waiting.

Simplicity in Implementation: With Spring WebFlux, creating an SSE endpoint is straightforward. You can use Mono or Flux to handle the stream of data and send updates to clients as they arrive.

Advantages of Using Spring WebFlux for SSE

Non-blocking & Reactive: Spring WebFlux is inherently reactive and non-blocking. It can efficiently manage numerous SSE streams without exhausting server threads, leading to highly responsive applications.

Superior Scalability: Thanks to its event-loop architecture, WebFlux can adeptly handle thousands of concurrent connections. This makes it an ideal choice for applications requiring high scalability.

Efficient Resource Utilization: Being asynchronous, WebFlux optimizes resource usage by freeing up server resources during wait times. This efficiency is particularly beneficial for SSE, where connections are often long-lived.

Backpressure Management: Built on Project Reactor, WebFlux provides robust backpressure support through Flux. This allows for controlled event flow, preventing overwhelming the client.

Seamless Reactive Data Integration: WebFlux integrates smoothly with Reactive Streams and reactive databases like R2DBC, MongoDB, and Cassandra. This ensures a cohesive, end-to-end reactive data pipeline.

Conclusion

Server-Sent Events provide a lightweight, efficient mechanism for real-time communication in scenarios where the server needs to push data to the client. Spring WebFlux makes it easy to implement SSE in a non-blocking and scalable way. While WebSockets can offer bi-directional communication, SSE shines in cases where the server needs to send real-time updates without the overhead of establishing and maintaining a full-duplex connection. 

To know more visit: Covalensedigital

Visit: Covalensedigital LinkedIn