Mastering Reactive Programming with Spring 5: From Basics to Real-World Examples

1. What is Reactive Development?

Spring 5 heavily supports Reactive Programming (responsive development). Both server and client can use this model; Spring 5 is built on the Reactor project.

In short, Reactive Programming is a non‑blocking, event‑driven data‑flow approach that uses functional programming concepts; when part of the system changes, other parts update automatically with minimal cost.

Reactive streams are non‑blocking, allowing data processing without waiting, which improves scalability because worker threads can handle more requests.

Example: loading user data from a database and forming a new collection of usernames.

① Traditional approach

② Functional collection processing

③ Reactive

Functional is more concise than the traditional method, but if the database is busy the thread blocks; reactive solves this with non‑blocking propagation, so the main thread isn’t tied to the operation, and a reactive caller creates a non‑blocking chain.

If the web server is reactive, request‑handling threads can immediately process other requests, and data is sent to the caller as soon as the database returns.

2. Backpressure

The key factor that makes reactive development surpass traditional methods is the backpressure mechanism, where the data‑flow producer knows the consumer’s processing capacity and adjusts production accordingly.

This awareness is crucial; for costly database operations, performing them only when the consumer is ready improves efficiency.

When the consumer is limited (e.g., network bandwidth), backpressure prevents over‑production, allowing the producer to signal the database to pause sending data, so the database can handle other requests, enhancing overall system efficiency.

3. Core Concepts of the Reactor Project

Spring 5 implements reactive development based on the Reactor project, which defines two core types – Mono and Flux .

Both represent data streams; Mono is a stream with at most one value, while Flux can emit an unlimited number of values.

Stream processing is lazy ; the producer generates data only after the consumer signals via subscribe() , for example:

The consumer passed to subscribe() handles each received item.

Java 9 already includes reactive streams , following the same ideas as Reactor. See the earlier article “Java 9 New Features: Reactive Streams”.

4. Sample Code

4.1 Controller

The controller looks similar to traditional code, using familiar annotations, but returns reactive types Flux and Mono . The framework handles the rest.

Comparing traditional and reactive approaches:

Traditional: the server reads all data from the database before sending to the client.

Reactive: as soon as data is ready, it is streamed to the client, like a flow.

This allows the client to display the first data sooner, and the server does not need to store all data; processing and transmission are immediate.

4.2 Data Layer

Database code also needs to be reactive. Spring Data provides support, though not yet complete—MongoDB works, but JDBC does not yet.

Example with MongoDB shows reactive database operations:

Two main differences from usual code: the repository interface changes from CrudRepository to ReactiveCrudRepository , and the return type becomes Flux . The changes are minimal.

5. Summary

Reactive Programming offers excellent maintainability and scalability; compared with blocking development, it delivers noticeably better performance with the same resources.

Source: https://stackify.com/reactive-spring-5/ Future articles will cover reactive development with Spring Boot 2.0.