Responsive programming implements high concurrency, low latency non-blocking services in Java through Project Reactor and Spring WebFlux. 1. Project Reactor provides two core types: Mono and Flux, supports declarative processing of asynchronous data flows, and converts, filters and other operations through operator chains; 2. Spring WebFlux is built on Reactor, supports two programming models of annotation and functional. It runs on non-blocking servers such as Netty, and can efficiently handle large amounts of concurrent connections; 3. Using WebFlux Reactor can improve concurrency capabilities and resource utilization in I/O-intensive scenarios, naturally supports streaming communications such as SSE and WebSocket, and seamlessly integrates with responsive databases such as R2DBC and MongoDB; 4. In actual applications, blocking code should be avoided, business logic should not be written in subscribe, and timeout and error guarantee mechanisms should be used reasonably; 5. Although the learning curve is steep and not suitable for CPU-intensive tasks, this combination can significantly improve system throughput and resilience in microservices, gateways, and real-time systems, and is worth adopting in suitable scenarios.

Reactive programming has become increasingly important in Java in recent years, especially in modern web applications with high concurrency and low latency. With Project Reactor and Spring WebFlux , Java developers can easily build non-blocking, event-driven services. Let's take a look at how they work together and why you should consider using them.

What is responsive programming?

Responsive programming is a programming paradigm for data flow and change propagation . It allows you to handle asynchronous data streams in a declarative manner, such as HTTP requests, database responses, message queues, etc.

In traditional blocking programming, each request occupies one thread and waits for the I/O operation to complete. In responsive programming, threads are not blocked, but are processed only when data is available through the "callback" or "publish-subscribe" mechanism.

Project Reactor: The core library for responsive programming

Project Reactor is a basic JVM library created by the Spring team for responsive systems. It is an implementation of Reactor 3 and is fully compatible with the Reactive Streams specification.

It provides two core types:

• Mono<t></t> : represents an asynchronous sequence of 0 or 1 element (for example: single user query results)
• Flux<t></t> : represents an asynchronous data stream of 0 to N elements (for example: get all users)

 // Example: Create a Flux
Flux<String> names = Flux.just("Alice", "Bob", "Charlie");

// Create a Mono
Mono<String> single = Mono.just("Hello");

You can chain these streams, such as map , filter , flatMap , delayElements , etc.:

 names
    .map(String::toUpperCase)
    .delayElements(Duration.ofMillis(500))
    .subscribe(System.out::println);

Note: The above code is non-blocking and will not be executed immediately, but "declare" the behavior of the data flow and will not be triggered until a "subscriber" appears.

Spring WebFlux: Responsive Web Framework

Spring WebFlux is a responsive web framework introduced by Spring 5. It can replace traditional Spring MVC and supports two programming models:

1. Annotated controller (similar to Spring MVC):

    @RestController
   public class UserController {
   
       @GetMapping("/users")
       public Flux<User> getAllUsers() {
           return userService.findAll(); // Return Flux<User>
       }
   
       @GetMapping("/users/{id}")
       public Mono<User> getUserById(@PathVariable String id) {
           return userService.findById(id); // Return Mono<User>
       }
   }

2. Functional routing model (lightweight, functional):

    @Bean
   public RouterFunction<ServerResponse> route(UserHandler handler) {
       return route(GET("/users"), handler::getAllUsers)
              .andRoute(GET("/users/{id}"), handler::getUserById);
   }

WebFlux supports non-blocking servers such as Netty and Undertow, Netty is recommended (the default is embedded in Spring Boot to use Reactor Netty).

Why use WebFlux Reactor?

1. Higher concurrency capability
   Traditional Tomcat occupies one thread per request, and the thread pool is limited. WebFlux uses a small number of event loop threads (Event Loops) that can handle thousands of concurrent connections.

2. Better resource utilization
   Non-blocking I/O reduces thread waiting, making CPU and memory usage more efficient.

3. Natural support for streaming data
   Such scenarios as SSE (Server-Sent Events), WebSocket, file flow, real-time push, etc. are very suitable.

4. Seamless integration with Spring Eco
   Supports responsive MongoDB, PostgreSQL (via R2DBC), Redis (Lettuce), Kafka, etc.

Recommendations and precautions for use

Although the advantages of responsive programming are obvious, it is not a silver bullet. Here are a few key points:

• ? Suitable for I/O-intensive scenarios : such as calling external APIs, database access, and message processing.
• ?Not suitable for CPU-intensive tasks : Responsiveness does not improve computing performance, but may increase complexity.
• ??Don't mix blocking code : calling Thread.sleep() or blocking database access in Mono/Flux will destroy the responsive advantage.
• ? Avoid writing business logic in subscribe : try to use operator chain processing to maintain functional style.
• ? The learning curve is steeper : the concepts of backpressure, scheduler, hot and cold flow require time to master.

Practical example: Calling external API

Suppose we want to obtain user information from an external service and do the conversion:

 @Service
public class UserService {

    private final WebClient webClient = WebClient.create("https://api.example.com");

    public Mono<User> fetchUser(String id) {
        return webClient.get()
            .uri("/users/{id}", id)
            .retrieve()
            .bodyToMono(ExternalUser.class)
            .map(this::convertToUser)
            .timeout(Duration.ofSeconds(3)) // Timeout control.onErrorReturn(User.empty()); // Error guarantee}
}

The entire process is non-blocking, and multiple requests can be processed in parallel without consuming additional threads.

Summarize

• Project Reactor provides basic operations for responsive streams ( Mono / Flux )
• Spring WebFlux is built on Reactor to implement responsive Web services
• Combination of the two, suitable for high concurrency, I/O-intensive applications
• When using it, you need to avoid blocking operations and understand the backpressure and scheduling mechanism

Responsive programming is not necessary everywhere, but in the right scenario, it can significantly improve the system's throughput and resilience. If you are building a microservice, gateway, real-time interface, or stream processing system, WebFlux Reactor deserves serious consideration.

Basically all is it, not complicated but it is easy to ignore details.

The above is the detailed content of Reactive Programming in Java with Project Reactor and Spring WebFlux. For more information, please follow other related articles on the PHP Chinese website!