Skip to main content

24 posts tagged with "webflux"

View All Tags

Reactive Programming in Spring WebFlux Series - XVII

· 4 min read

In the previous sixteen articles, we have covered the foundational concepts of Spring WebFlux, Reactor, data stream transformation, reactive database access, performance optimization, security, testing, deployment and operations, best practices, common pitfalls, integration with microservices architecture, and real-time data push. This article will delve into implementing effective error handling strategies in Spring WebFlux applications to ensure system robustness and user experience.


Error Handling Strategies


Importance of Error Handling​

In any application, errors are inevitable. How these errors are handled not only affects system stability but also directly impacts user experience. In Spring WebFlux, due to its asynchronous and non-blocking nature, error handling is particularly crucial.

Basic Concepts of Error Handling​

In Spring WebFlux, error handling typically involves the following levels:

  • Global Error Handling: Captures unhandled exceptions in the application and provides a unified error response.
  • Controller-Level Error Handling: Handles errors specific to requests in controllers.
  • Error Handling in Reactive Streams: Manages and recovers from errors within reactive data streams.

Global Error Handling​

Global error handling can be achieved by implementing the ErrorWebExceptionHandler interface.

Creating a Global Error Handler​

import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Configuration
public class GlobalErrorHandlerConfig {

@Bean
@Order(-2)
public ErrorWebExceptionHandler globalErrorHandler() {
return new GlobalErrorHandler();
}

private static class GlobalErrorHandler implements ErrorWebExceptionHandler {

@Override
public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
ServerRequest request = ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
return renderErrorResponse(request, ex)
.flatMap(response -> response.writeTo(exchange, HandlerStrategies.withDefaults()));
}

private Mono<ServerResponse> renderErrorResponse(ServerRequest request, Throwable ex) {
return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR)
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(new ErrorResponse(ex.getMessage()));
}
}

private static class ErrorResponse {
private final String message;

public ErrorResponse(String message) {
this.message = message;
}

public String getMessage() {
return message;
}
}
}

Configuration Class Explanation​

In the above configuration, we define a global error handler GlobalErrorHandler that captures all unhandled exceptions and returns a unified error response. By implementing the ErrorWebExceptionHandler interface, we can customize the error handling logic.

Controller-Level Error Handling​

At the controller level, we can use the @ExceptionHandler annotation to handle specific exceptions.

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.http.ResponseEntity;

@RestControllerAdvice
public class ControllerExceptionHandler {

@ExceptionHandler(BookNotFoundException.class)
public ResponseEntity<ErrorResponse> handleBookNotFound(BookNotFoundException ex) {
ErrorResponse errorResponse = new ErrorResponse(ex.getMessage());
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
}

// Handle other exceptions
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleException(Exception ex) {
ErrorResponse errorResponse = new ErrorResponse("Internal Server Error");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
}
}

Error Handling in Reactive Streams​

In reactive streams, we can use various operators to handle errors.

Using onErrorResume​

The onErrorResume operator allows switching to another Publisher when an error occurs.

public Mono<Book> findBookById(String id) {
return bookRepository.findById(id)
.onErrorResume(ex -> {
log.error("Error finding book", ex);
return Mono.empty();
});
}

Using onErrorReturn​

The onErrorReturn operator allows returning a default value when an error occurs.

public Mono<Book> findBookById(String id) {
return bookRepository.findById(id)
.onErrorReturn(new Book("default", "Default Book", "Unknown Author", 0.0));
}

Using onErrorMap​

The onErrorMap operator allows converting the error to another type of error.

public Mono<Book> findBookById(String id) {
return bookRepository.findById(id)
.onErrorMap(ex -> new CustomException("Custom error message", ex));
}

Conclusion​

In this article, we explored how to implement effective error handling strategies in Spring WebFlux applications. By using global error handling, controller-level error handling, and error handling in reactive streams, we can build more robust and user-friendly applications. Proper error handling is essential for maintaining the reliability and performance of modern reactive applications.

Deep Dive Backpressure Flow Control with WebClient in Spring Boot

· 5 min read

1. Introduction to Backpressure​

Backpressure is the mechanism in reactive systems that helps manage the flow of data between producers and consumers. In systems where data is produced at high rates, backpressure allows consumers to signal how much data they can process, preventing overload.

Without backpressure, if the producer emits data faster than the consumer can process, it can lead to memory overflows, crashes, or degraded system performance.


2. Why Backpressure is Important​

Backpressure ensures:

  • Efficient resource management
  • Prevents overwhelming downstream services
  • Provides resilience against data surges
  • Allows consumers to control the data inflow rate

Reactive systems like Spring’s WebClient use backpressure to provide flow control, especially when dealing with streaming data or high-throughput APIs.


3. WebClient: Enabling Backpressure​

WebClient, built on Project Reactor, supports backpressure natively through Flux and Mono types. By controlling the rate at which data is processed, WebClient ensures that reactive streams can handle large datasets or slow consumers.

Example initialization:

WebClient webClient = WebClient.builder()
.baseUrl("https://dummy.restapiexample.com/api/v1/employees")
.build();

WebClient operates on non-blocking, reactive pipelines where consumers can request more data as needed, unlike traditional blocking REST clients.


4. Use Case​

Example: Streaming Large Dataset with Backpressure​

Imagine you're building a data ingestion service that consumes streaming data from an external API, such as real-time stock market prices. The API provides thousands of updates per second. Your system must process this data without overwhelming downstream services (e.g., databases or other microservices).

You can use WebClient with backpressure to process these updates at a controlled rate, avoiding memory overloads and ensuring stability.

Code Example:​

WebClient webClient = WebClient.create("https://dummy.restapiexample.com/api/v1/employees");

Flux<StockPrice> stockPriceStream = webClient.get()
.uri("/stream")
.retrieve()
.bodyToFlux(StockPrice.class)
.limitRate(100); // Limit the rate of data processing

stockPriceStream
.doOnNext(stock -> processStockPrice(stock))
.doOnError(error -> handleError(error))
.subscribe();

Here, limitRate(100) ensures that only 100 stock price updates are processed at a time, preventing overload.


5. Backpressure Strategies in WebClient​

Strategy 1: limitRate​

The simplest method to apply backpressure is by limiting the rate at which data is processed using limitRate().

Example:

Flux<StockPrice> stockPriceStream = webClient.get()
.uri("/stream")
.retrieve()
.bodyToFlux(StockPrice.class)
.limitRate(50); // Controls backpressure with 50 items at a time

This limits the number of items requested and processed at a time.


Strategy 2: onBackpressureBuffer​

The onBackpressureBuffer operator buffers data when backpressure occurs, until the downstream can handle it.

Flux.range(1, 1000)
.onBackpressureBuffer(50)
.subscribe(System.out::println);

Strategy 3: onBackpressureDrop​

The onBackpressureDrop operator discards data when backpressure occurs to prevent downstream overload.

Flux.range(1, 1000)
.onBackpressureDrop()
.subscribe(System.out::println);

Strategy 4: Using Flux.window()​

Another method is using window(), which batches items into smaller chunks for processing.

Example:

Flux<StockPrice> stockPriceStream = webClient.get()
.uri("/stream")
.retrieve()
.bodyToFlux(StockPrice.class)
.window(10) // Process in windows of 10
.flatMap(window -> window.collectList())
.doOnNext(batch -> processBatch(batch))
.subscribe();

This groups items into windows of 10 before processing, providing an additional layer of control.


Strategy 5: Combining flatMap with Concurrency​

For more complex backpressure control, you can combine flatMap() with concurrency settings. This allows concurrent processing of items with backpressure.

Example:

webClient.get()
.uri("/stream")
.retrieve()
.bodyToFlux(StockPrice.class)
.flatMap(price -> processStockPrice(price), 5) // Concurrently process 5 items
.subscribe();

Here, flatMap() ensures that a maximum of 5 stock prices are processed concurrently at any given time.


6. Diagrams​

Diagram 1: Basic Backpressure Flow​

[Producer] ---> [Backpressure Mechanism (limitRate, window)] ---> [Consumer]
^ |
| v
+--------------------------------------------------------------
  1. Producer sends data.
  2. Backpressure mechanism (e.g., limitRate) controls the flow.
  3. Consumer processes data at a controlled rate.

Diagram 2: Streaming Data with Concurrency and Backpressure​

[API] ---> [WebClient (Stream)] ---> [Backpressure] ---> [Concurrent Processing] ---> [Final Consumer]
^ ^ | | |
| | | +---> [Worker 1] |
| +------------------------+ +---> [Worker 2] |
+------------------------------------------------------------------------------------------------+

7. Conclusion​

In reactive systems, backpressure is a key mechanism that prevents overload and ensures stable operation by allowing consumers to control the rate of data consumption. With WebClient, backpressure can be easily managed using strategies like limitRate, window, and flatMap with concurrency.

Compared to traditional, blocking clients like RestTemplate, WebClient’s backpressure control is a major advantage for high-throughput, non-blocking operations.

By implementing these techniques, you can design robust, scalable applications that handle large datasets and high-velocity data streams with ease.

Deep Dive Spring Boot Retry Mechanism and Implementation

· 9 min read

Spring Boot Retry Mechanism - Detailed Guide with Sample Code


1. Introduction to Spring Retry​

Spring Boot provides a robust retry mechanism through the Spring Retry module. This module allows developers to automatically retry operations that fail due to certain exceptions, making it highly useful for handling transient faults in distributed systems, such as network issues, service unavailability, and more.

Spring Retry can be implemented in two primary ways:

  • Programmatically using RetryTemplate.
  • Declaratively using the @Retryable annotation.

Additionally, Spring Retry supports recovery methods using the @Recover annotation, which can be invoked when all retry attempts are exhausted.

Key Features:​

  • Retry Policies: Define the number of retry attempts and conditions for retrying.
  • Backoff Policies: Implement delays between retries, including fixed, exponential, and custom backoff strategies.
  • Exception Handling: Retry based on specific exceptions or generic conditions.
  • Recovery Mechanism: Gracefully handle failures using @Recover methods.

2. How Retry Mechanism Works​

The retry mechanism in Spring operates as follows:

  • When a method annotated with @Retryable or executed via RetryTemplate encounters an exception, Spring can automatically retry that method a configurable number of times.
  • The retry logic can be customized based on specific exceptions or broader conditions.
  • Spring supports various backoff policies, such as fixed delays, exponential backoff, and custom backoff strategies, to manage the interval between retry attempts.
  • After exhausting the maximum retry attempts, a @Recover method can be invoked to handle the failure gracefully.

Flow of Retry Mechanism:​

  1. Method Invocation: The retryable method is invoked.
  2. Exception Occurs: If an exception occurs, Spring checks if the method is retryable.
  3. Retry Policy: The retry policy determines whether to retry the method.
  4. Backoff Policy: If retries are allowed, the backoff policy defines the delay before the next retry.
  5. Retry Execution: The method is retried according to the defined policy.
  6. Recovery: If all retries fail, the @Recover method is invoked.

3. Plain Retry Implementation using RetryTemplate​

The RetryTemplate is used to implement the retry mechanism programmatically. This approach provides fine-grained control over the retry logic and is ideal for complex scenarios.

Step-by-Step Guide:​

  1. Add Dependencies in pom.xml (if using Maven):
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
  1. Define RetryTemplate Bean:
@Configuration
public class RetryConfig {
@Bean
public RetryTemplate retryTemplate() {
RetryTemplate retryTemplate = new RetryTemplate();

// Define retry policy (e.g., 3 attempts for any exception)
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
retryPolicy.setMaxAttempts(3);

// Define backoff policy (e.g., 2 seconds between retries)
FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
backOffPolicy.setBackOffPeriod(2000); // 2000 ms = 2 seconds

retryTemplate.setRetryPolicy(retryPolicy);
retryTemplate.setBackOffPolicy(backOffPolicy);

return retryTemplate;
}
}
  1. Use RetryTemplate in Business Logic:
@Service
public class MyService {

@Autowired
private RetryTemplate retryTemplate;

public void performTask() {
retryTemplate.execute(context -> {
// Logic that might fail
System.out.println("Attempting task...");
if (new Random().nextInt(10) < 8) {
throw new RuntimeException("Failed task");
}
System.out.println("Task succeeded");
return null;
});
}
}
  1. Main Application:
@SpringBootApplication
public class RetryApplication {
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(RetryApplication.class, args);
MyService service = context.getBean(MyService.class);
service.performTask();
}
}

Key Points:​

  • RetryTemplate: Provides a flexible way to define retry policies and backoff strategies.
  • SimpleRetryPolicy: Defines the maximum number of retry attempts.
  • FixedBackOffPolicy: Sets a fixed delay between retry attempts.
  • execute() Method: Executes the retry logic within a lambda expression.

4. Annotation-Based Retry Implementation using @Retryable​

The annotation-based approach uses the @Retryable annotation to automatically retry methods without explicitly defining a RetryTemplate. This method is simpler and more concise, making it ideal for straightforward retry scenarios.

Step-by-Step Guide:​

  1. Add Dependencies (same as in RetryTemplate approach).

  2. Enable Retry in Spring Boot Application:

@SpringBootApplication
@EnableRetry
public class RetryApplication {
public static void main(String[] args) {
SpringApplication.run(RetryApplication.class, args);
}
}
  1. Use @Retryable Annotation:
@Service
public class MyService {

@Retryable(
value = { RuntimeException.class }, // Retry on specific exceptions
maxAttempts = 3, // Retry up to 3 times
backoff = @Backoff(delay = 2000) // 2 seconds delay between retries
)
public void performTask() {
System.out.println("Attempting task...");
if (new Random().nextInt(10) < 8) {
throw new RuntimeException("Task failed");
}
System.out.println("Task succeeded");
}
}
  1. Recover from Failure using @Recover: You can define a recovery method that will be called when all retry attempts are exhausted.
@Service
public class MyService {

@Retryable(
value = { RuntimeException.class },
maxAttempts = 3,
backoff = @Backoff(delay = 2000)
)
public void performTask() {
System.out.println("Attempting task...");
if (new Random().nextInt(10) < 8) {
throw new RuntimeException("Task failed");
}
System.out.println("Task succeeded");
}

@Recover
public void recover(RuntimeException e) {
System.out.println("Recovering from failure: " + e.getMessage());
}
}

Key Points:​

  • @Retryable: Specifies the method to be retried, along with the retry conditions and backoff policy.
  • @Recover: Defines a fallback method to handle failures after all retries are exhausted.
  • @EnableRetry: Enables the retry mechanism in the Spring Boot application.

5. Recovering from Failure using @Recover​

The @Recover annotation is used to define a fallback method that will be called when all retry attempts fail. This method allows you to handle the failure gracefully and provide a fallback response.

Key Points:​

  • The method annotated with @Recover must have the same return type as the retryable method.
  • It must accept the exception type being handled as a parameter.

Example:

@Recover
public String recoverFromFailure(RuntimeException e) {
System.out.println("Recovery logic for exception: " + e.getMessage());
return "Fallback result";
}

In the above example, when all retries fail, the recoverFromFailure() method will be called, and the fallback result will be returned.

Advanced Recovery:​

  • Multiple @Recover Methods: You can define multiple recovery methods for different exception types, allowing for more granular error handling.
  • Parameter Matching: The recovery method's parameters must match the retryable method's parameters, except for the first parameter, which must be the exception type.

6. Flowchart: Retry Mechanism​

Below is a textual representation of the Spring Boot retry mechanism flowchart:

+------------------------------------------+
| Start Application |
+------------------------------------------+
|
V
+------------------------------------------+
| Method Invoked (e.g., performTask) |
+------------------------------------------+
|
V
+---------------------------------------------------+
| Is Retryable? (Check @Retryable or RT) |
+---------------------------------------------------+
Yes | No |
V V
+-------------------------------------+ +-----------------------------+
| Try Method Execution | | No retry, continue normal |
| | | method execution |
+-------------------------------------+ +-----------------------------+
|
V
+--------------------------------------------------+
| Method Execution Fails? |
+--------------------------------------------------+
Yes | No |
V V
+------------------------------------------+ +-----------------------------+
| Retry Policy Check (max attempts?) | | Method succeeds, continue |
+------------------------------------------+ +-----------------------------+
Yes | No |
V V
+------------------------------------------+ +-----------------------------+
| Retry Backoff (delay before retry) | | Call @Recover method |
+------------------------------------------+ +-----------------------------+
|
V
+------------------------------------------+
| Retry Method Execution |
+------------------------------------------+
|
V
+-------------------------------------------------------+
| Retry Limit Reached or Success? |
+-------------------------------------------------------+
Retry Limit | Success |
V V
+------------------------------------------+ +-----------------------------+
| Call @Recover method | | Continue normal execution |
+------------------------------------------+ +-----------------------------+

Key Points:​

  • Retryable Check: Determines if the method is eligible for retries.
  • Retry Policy: Defines the number of retry attempts and conditions.
  • Backoff Policy: Manages the delay between retry attempts.
  • Recovery Method: Handles failures after all retries are exhausted.

7. Multiple Recover Methods​

In Spring Retry, while it might seem like there is no explicit way to specify a "recover" method in the @Retryable annotation itself, you can still have multiple recover methods in the same class. Spring Retry allows you to define different recovery methods by relying on method signatures.

The framework will match the appropriate recovery method based on the parameters of the method, so each @Recover method corresponds to a specific exception type (or a list of exception types) that it's designed to handle.

Example: Multiple @Recover Methods​

@Service
public class ApiService {

private final RestTemplate restTemplate;

@Autowired
public ApiService(RestTemplateBuilder restTemplateBuilder) {
this.restTemplate = restTemplateBuilder.build();
}

// Retryable method for HTTP client errors
@Retryable(
value = { HttpClientErrorException.class },
maxAttempts = 4,
backoff = @Backoff(delay = 1000)
)
public String invokeClientApi(String url) {
return restTemplate.getForObject(url, String.class);
}

// Retryable method for HTTP server errors
@Retryable(
value = { HttpServerErrorException.class },
maxAttempts = 4,
backoff = @Backoff(delay = 1000)
)
public String invokeServerApi(String url) {
return restTemplate.getForObject(url, String.class);
}

// Recovery method for HTTP client errors
@Recover
public String recoverClientError(HttpClientErrorException e, String url) {
return "Client error fallback for URL: " + url;
}

// Recovery method for HTTP server errors
@Recover
public String recoverServerError(HttpServerErrorException e, String url) {
return "Server error fallback for URL: " + url;
}
}

Key Points:​

  • Different @Recover methods are defined based on the exception type (e.g., HttpClientErrorException vs. HttpServerErrorException).
  • The recovery method's first parameter is the exception type that triggered the retry failure. This is how Spring determines which recover method to invoke.
  • Additional parameters (like url in the example) must match the parameters of the corresponding retryable method.

How It Works:​

  1. If the retryable method (invokeClientApi or invokeServerApi) fails after exhausting the retry attempts, Spring will look for a recovery method based on the exception type.
  2. The recovery method (recoverClientError or recoverServerError) will be called depending on whether a HttpClientErrorException or a HttpServerErrorException occurred.

Summary:​

A class can have multiple @Recover methods. Spring matches the correct recovery method based on the exception type and method signature, so you can create recover methods for different types of exceptions in the same class.


8. Conclusion​

Spring Boot’s retry mechanism provides a simple and powerful way to retry failed operations, with both programmatic (RetryTemplate) and declarative (@Retryable) support. Additionally, recovery methods allow handling failure gracefully after retry attempts are exhausted.

Whether you choose to use RetryTemplate or @Retryable, both approaches are robust solutions for retrying failed methods in Spring applications.

Key Takeaways:​

  • RetryTemplate: Offers fine-grained control over retry logic.
  • @Retryable: Provides a simpler, declarative approach to retries.
  • @Recover: Enables graceful handling of failures after retries are exhausted.
  • Multiple Recover Methods: Allows for granular error handling based on exception types.

By leveraging Spring Retry, developers can build resilient applications that can handle transient faults effectively, ensuring higher availability and reliability.

WebClient and RestTemplate in Spring Boot

· 10 min read

WebClient and RestTemplate in Spring Boot


1. Overview​

Spring Boot offers two primary ways to make HTTP requests: RestTemplate and WebClient. While both can be used to interact with external APIs, they differ significantly in features, capabilities, and usage. In this article, we'll explore the key differences, when to use each, and best practices through practical examples.

2. What is RestTemplate?​

RestTemplate is a synchronous client designed to perform HTTP requests and handle responses. It has been around for a long time and is simple to use but is gradually being deprecated in favor of WebClient for reactive programming.

Characteristics:​

  • Synchronous/blocking operations: Each request blocks the thread until the response is received.
  • Easy to use: Simplified API for HTTP interactions.
  • Wide range of RESTful operations: Supports GET, POST, PUT, DELETE, etc.
  • Deprecated: Spring team recommends using WebClient for new applications.

Code Sample:​

RestTemplate restTemplate = new RestTemplate();
String url = "https://catfact.ninja/facts";
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);

System.out.println("Response: " + response.getBody());

3. What is WebClient?​

WebClient is the successor to RestTemplate, introduced in Spring 5. It supports both synchronous and asynchronous (non-blocking) calls and is designed for reactive programming, making it more suitable for modern web applications.

Characteristics:​

  • Asynchronous and non-blocking: Allows multiple requests to be handled concurrently without blocking threads.
  • Part of Spring WebFlux: Built on top of the reactive stack.
  • Supports backpressure: Crucial for reactive streams to manage data flow.
  • Chaining operations: Allows declarative chaining of multiple operations.

Code Sample:​

WebClient webClient = WebClient.create("https://catfact.ninja");

Mono<String> response = webClient.get()
.uri("/facts")
.retrieve()
.bodyToMono(String.class);

response.subscribe(System.out::println);

4. Key Differences​

FeatureRestTemplateWebClient
TypeSynchronousAsynchronous and Reactive
ConcurrencyBlocking (each request waits)Non-blocking (multiple requests in parallel)
BackpressureNo (Processes whole response at once)Yes, Supports backpressure in reactive systems, flow control
Error HandlingSimple but lacks flexibilityAdvanced error handling with .onStatus()
Support for StreamsNoYes, can handle large streams of data
FlexibilityLimited customizationsHighly flexible and configurable

4.1 Synchronous vs Asynchronous​

  • RestTemplate: Operates in a synchronous/blocking fashion, meaning the thread is blocked until the response arrives.
  • WebClient: Can operate both synchronously and asynchronously, allowing for non-blocking I/O and better scalability.

4.2 Reactive Support​

WebClient is built to support the reactive paradigm of programming, which allows applications to handle a massive number of requests efficiently by leveraging non-blocking I/O operations. RestTemplate does not have this support.

4.3 Error Handling​

WebClient provides more flexible error handling with methods like .onStatus() for dealing with specific HTTP status codes.

4.4 Performance​

Due to its asynchronous nature, WebClient typically offers better performance in handling multiple HTTP requests concurrently, making it more suitable for high-performance applications.

4.5 Flexibility & Features​

WebClient can be configured with timeouts, retries, and fallbacks more easily compared to RestTemplate. It supports streaming large amounts of data and provides reactive streams to manage data flow.

5. Best Practices and Use Cases​

  • When to use RestTemplate:

    • Small applications with minimal requirements for concurrency.
    • Use cases where synchronous/blocking operations are acceptable.
  • When to use WebClient:

    • Modern applications requiring scalability and performance.
    • When working with large-scale microservices architectures.
    • For non-blocking and reactive API calls.

Best Practices:​

  • Use WebClient for new applications that need to scale.
  • Avoid using RestTemplate for large-scale systems due to its synchronous nature.
  • Handle errors properly using onStatus() in WebClient.

6. Real-Life Use Case Example​

Let's assume a situation where you are building a service to fetch data from multiple APIs concurrently. RestTemplate would block on each request, but WebClient would allow you to make all the calls concurrently and return the responses as they come in.

6.1 Using RestTemplate (Synchronous)​

@RestController
public class ApiController {

private RestTemplate restTemplate = new RestTemplate();

@GetMapping("/data")
public String fetchData() {
String api1Response = restTemplate.getForObject("https://catfact.ninja/facts", String.class);
String api2Response = restTemplate.getForObject("https://catfact.ninja/fact", String.class);
return "Data from API1: " + api1Response + " and API2: " + api2Response;
}
}

6.2 Using WebClient (Asynchronous)​

@RestController
public class ApiController {

private WebClient webClient = WebClient.create();

@GetMapping("/data")
public Mono<String> fetchData() {
Mono<String> api1Response = webClient.get().uri("https://catfact.ninja/facts").retrieve().bodyToMono(String.class);
Mono<String> api2Response = webClient.get().uri("https://catfact.ninja/fact").retrieve().bodyToMono(String.class);

return Mono.zip(api1Response, api2Response, (api1, api2) -> "Data from API1: " + api1 + " and API2: " + api2);
}
}

6.3 Adding Retry and Fallback (WebClient)​

public class ApiService {

private WebClient webClient = WebClient.builder()
.baseUrl("https://catfact.ninja")
.filter(ExchangeFilterFunctions.statusError(HttpStatus::is4xxClientError, clientResponse -> new RuntimeException("API Error")))
.build();

@Retryable(value = {RuntimeException.class}, maxAttempts = 3)
public Mono<String> fetchDataWithRetry() {
return webClient.get()
.uri("/data")
.retrieve()
.bodyToMono(String.class)
.onErrorReturn("Fallback Data");
}
}

7. Conclusion​

RestTemplate is simple and suitable for synchronous applications, but for modern, scalable applications, WebClient is the clear choice due to its non-blocking and reactive features. In Spring Boot applications, it's recommended to move towards WebClient for future-proofing your code.

8. Diagrams​

8.1 Synchronous RestTemplate Workflow​

Request -> Server -> Blocking I/O -> Response -> Client

8.2 Asynchronous WebClient Workflow​

Request -> Server -> Non-Blocking I/O -> Reactive Stream -> Response -> Client

9. Deep Dive into Backpressure​

9.1 What is Backpressure in Reactive Systems?​

Backpressure refers to a mechanism used in reactive systems to control the flow of data between producers and consumers. It allows the consumer to handle data at a rate it can manage, preventing overload or crashes. If the producer is emitting data faster than the consumer can process, backpressure signals the producer to slow down or pause until the consumer catches up.

9.2 Is Backpressure Good or Bad?​

Good:

  • Efficient Resource Management: Backpressure prevents resource exhaustion by controlling how much data is in the system.
  • System Stability: It helps prevent overloading a service, ensuring it operates smoothly without being overwhelmed by data.
  • Improved Scalability: In distributed systems, especially when handling streams of real-time data, backpressure enables better scalability and responsiveness.

Challenges:

  • Increased Complexity: While beneficial, backpressure introduces more complexity in system design. Developers need to think carefully about flow control.
  • Latency: If not managed properly, backpressure can introduce latency because the producer has to wait until the consumer is ready to receive more data.

9.3 How WebClient Supports Backpressure​

In Spring WebFlux, WebClient works in a reactive, non-blocking way and is integrated with Project Reactor to support backpressure. When fetching large streams of data, WebClient can handle them without overwhelming the system. Here's how it works:

  • Reactive Streams: WebClient communicates using Publisher and Subscriber patterns, which allows it to handle streams of data asynchronously. If the subscriber (consumer) is slower than the publisher (producer), it can request data at a manageable rate, applying backpressure when needed.

  • Flow Control: In a typical scenario, the subscriber can signal how much data it wants to receive at any given moment. This avoids a flood of data that could cause the system to run out of resources. WebClient ensures that consumers can throttle the data based on their processing capacity.

9.4 Code Example of WebClient Supporting Backpressure​

WebClient webClient = WebClient.create();

Flux<String> response = webClient.get()
.uri("/large-data-stream")
.retrieve()
.bodyToFlux(String.class)
.limitRate(10); // apply backpressure by limiting the rate of consumption

response.subscribe(data -> {
System.out.println("Processing: " + data);
});

In this example, the limitRate() method ensures the consumer processes the data stream at a manageable rate, effectively applying backpressure.

9.5 Why RestTemplate Doesn't Have Backpressure​

RestTemplate is built on a blocking I/O model, which means it waits for each HTTP request to complete before proceeding to the next task. This approach works well for synchronous operations, but it lacks the flow control mechanisms needed for backpressure. Here's why RestTemplate doesn't support backpressure:

  1. Blocking Nature: RestTemplate blocks the current thread while waiting for a response, handling each request in sequence, which inherently prevents a need for backpressure.

  2. Lack of Reactive Streams: Unlike WebClient, which is built around reactive streams and the non-blocking Publisher-Subscriber pattern, RestTemplate doesn't have the underlying architecture to request data in chunks or manage flow control. It processes the entire response in a blocking call and holds it in memory until the response is complete.

  3. Thread-per-request Model: RestTemplate uses a traditional thread-per-request model, which consumes a thread for the entire duration of a request. This model isn't designed to handle large streams of data efficiently or manage backpressure when dealing with data that arrives at varying rates.

9.6 When to Use RestTemplate​

RestTemplate is still useful for simple, synchronous tasks that don’t require fine-grained control over how data is processed, particularly when working with legacy systems or simple API interactions that don't involve heavy real-time data streaming.

However, for reactive programming, high throughput, and complex asynchronous data handling, WebClient is the better choice, as it is designed to handle backpressure effectively.

9.7 Conclusion​

Backpressure is essential in reactive systems for maintaining stability and scalability. Spring WebClient leverages Project Reactor to support it, making it an excellent choice for modern applications handling large streams of data. While it adds some complexity, the benefits of resource management and smooth performance outweigh the drawbacks.

Key Takeaways:​

  • Backpressure: A mechanism to control data flow in reactive systems.
  • WebClient: Supports backpressure and is suitable for modern, scalable applications.
  • RestTemplate: Synchronous and blocking, not suitable for handling large streams of data.
  • Best Practices: Use WebClient for new applications requiring scalability and performance.