Sunday, August 13, 2023

Difference between RestTemplate and WebClient in Spring Boot? Example

Welcome to the blog post. Today we are going to take an in-depth look at the difference between two of the Spring framework’s web client implementations i.e. RestTemplate and WebClient. As usual before moving to the topic, let us give you a thorough understanding of the two Libraries so, without further ado let’s jump into the topic.  RestTemplate and WebClient are both popular libraries provided by the Spring Framework for making HTTP requests to external APIs. While they both serve the same purpose, they have some fundamental differences that make them suitable for different use cases. In this article, we will explore the differences between RestTemplate and WebClient, with the help of examples.

1. RestTemplate

RestTemplate is a synchronous client that offers a higher-level API for sending HTTP requests. It has been a component of the Spring Framework since version 3.0. It simplifies the process of interacting with external APIs by providing methods for performing various HTTP requests like GET, POST, PUT, DELETE, etc. 

The conversion of request and response data into and out of other forms, such as JSON, XML, etc., is another task handled by RestTemplate.

RestTemplate has many features like handling HTTP headers, handling cookies, handling response codes, etc. It also supports asynchronous requests using AsyncRestTemplate. RestTemplate is thread-safe and can be used in a multi-threaded environment.

Here's an example of how to use RestTemplate to perform a GET request and extract the response body as a JSON string:

RestTemplate restTemplate = new RestTemplate();

String url = "https://jsonplaceholder.typicode.com/posts/1";

String response = restTemplate.getForObject(url, String.class);

System.out.println(response);


In this example, we have created a fresh instance of the RestTemplate class and provided the URL we wish to ask for. The answer is then returned as a string by sending a GET request to the provided URL using the getForObject() function.

Difference between RestTemplate vs WebClient in Spring Framework



2. WebClient

Introduced in Spring 5.0, WebClient is a non-blocking, reactive HTTP client. In comparison to RestTemplate, it offers a more adaptable and effective method of making HTTP requests. It is based on the Reactive Streams standard. WebClient supports both synchronous and asynchronous requests and may be used with any reactive library, such as Reactor and RxJava.

Here's an example of how to use WebClient to perform a GET request and extract the response body as a JSON string:

WebClient webClient = WebClient.create();

String url = "https://jsonplaceholder.typicode.com/posts/1";

String response = webClient.get()

.uri(url)

.retrieve()

.bodyToMono(String.class)

.block();

System.out.println(response);


In the above example, we establish a new WebClient instance and enter the URL that we wish to ask for. Then, we use the uri method to specify the URL and the get function to construct a GET request. Following that, we receive the response body as a Mono object using the retrieve method and convert the response body to a string using the bodyToMono() method. 

Finally, we block using the block method and wait for the answer to arrive before returning it as a string.

WebClient also supports other HTTP methods like POST, PUT, and DELETE, and can be used to make requests with request headers, query parameters, and request bodies. 

Here's an example of how to use WebClient to make a POST request with a request body

@Autowired

private WebClient webClient;


public void makeHttpPostRequest() {

String url = "https://jsonplaceholder.typicode.com/posts";

Mono<String> response = webClient.post()

.uri(url)

.contentType(MediaType.APPLICATION_JSON)

.bodyValue("{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}")

.retrieve()

.bodyToMono(String.class);

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

}


We construct a POST request in this example. Using the bodyValue function, we set the request body and the URL we wish to request. Using the contentType method, we can also change the request's content type. The response body is then obtained using the retrieve function and transformed into a Mono object of type String. The answer is then printed to the console after subscribing to the Mono object.

Difference between RestTemplate vs WebClient in Spring Boot




Difference between RestTemplate vs WebClient in Spring Framework

Now, let's see the difference between RestTemplate and WebClient class in Spring Boot and Java:

1. Performance
When we conducted performance testing with several concurrent client requests in order to compare the differences between these two ways.

After a certain number of concurrent client requests, the blocking method's performance would noticeably decline.

The reactive/non-blocking approach, however, ought to deliver consistent performance regardless of the number of requests.

WebClient is typically thought of as being quicker and more effective than RestTemplate. Compared to RestTemplate, due to its capabilities for non-blocking I/O. WebClient can handle a greater volume of requests with more efficiency and less resource use.


2. Synchronous vs. Asynchronous
The way that RestTemplate and WebClient handle requests differ significantly from one another. Because RestTemplate is a synchronous client, it waits for the server's response before executing the remaining portions of the code. WebClient, on the other hand, makes better use of system resources since it is an asynchronous client, which means that it sends the request and continues with the rest of the code execution.


3. Thread Safety
RestTemplate may be used in a multi-threaded context and is thread-safe. The fact that RestTemplate is not reactive and does not provide non-blocking I/O must be noted. The WebClient, on the other hand, supports non-blocking I/O and is built for usage in a reactive context.


4. Flexibility
When it comes to reactive programming, WebClient offers more flexibility than RestTemplate. WebClient supports both synchronous and asynchronous requests and may be used with any reactive library, such as Reactor and RxJava. Contrarily, RestTemplate can only be used with blocking I/O libraries and is restricted to the synchronous method.


5. Error handling
Error management is commonly carried out in RestTemplate via try-catch blocks or the built-in exception handling features. Using reactive programming structures like onErrorResume() or onErrorReturn(), WebClient normally handles errors. Reactive error handling with WebClient offers additional flexibility and makes it simpler to handle failures in a non-blocking manner.


6.  Serialization and Deserialization
Both RestTemplate and WebClient support serialising and deserializing request and response bodies to and from a variety of forms, such as JSON, XML, etc. WebClient, on the other hand, gives developers more freedom and control over the serialisation and deserialization process, enabling them to adapt it to their own needs.


7. Configuration
RestTemplate: To make use of RestTemplate in our project you need the following dependency in your project.


<dependency>

  <groupId>org.springframework.boot</groupId>

  <artifactId>spring-boot-starter-web</artifactId>

</dependency>


WebClient: To make use of WebClient, we need the following dependency in your Spring Boot project.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>



Conclusion
That's all about difference between RestTemplate and WebClient in Spring Boot. The Spring Framework offers two strong libraries for sending HTTP queries to external APIs: RestTemplate and WebClient. While WebClient is a non-blocking, reactive HTTP client that offers a more adaptable and effective way to make HTTP queries, RestTemplate is a synchronous client that offers a higher-level API for making HTTP requests. 

You should carefully weigh the trade-offs before selecting one library over another since it depends on the unique use case. In general, WebClient is the best option if the application needs to handle HTTP requests in a reactive and non-blocking manner. RestTemplate is a good choice if the application needs a more conventional, blocking I/O strategy.

Other Spring MVC articles and Tutorials you may like
Thanks a lot for reading this article so far. If you like this Java and Spring Boot tutorial then please share them with your friends and colleagues. If you have any questions or feedback then please drop a note. 
at

No comments:

Post a Comment