Understanding RestTemplate in Java Spring: When and How to Use It

RestTemplate is a class provided by the Spring Framework that simplifies the process of making HTTP requests and handling responses. It…

Pallavi Devraye

~5 min read · June 2, 2024 (Updated: June 2, 2024) · Free: Yes

RestTemplate is a class provided by the Spring Framework that simplifies the process of making HTTP requests and handling responses. It abstracts away much of the boilerplate code typically associated with making HTTP calls, making it easier to interact with RESTful web services.

Getting Started with RestTemplate

Adding Dependencies

To use RestTemplate, you need to include the Spring Web dependency in your pom.xml file if you're using Maven:

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

For Gradle, add the following dependency to your build.gradle file:

implementation 'org.springframework.boot:spring-boot-starter-web'

Creating a RestTemplate Bean

It's a common practice to define a RestTemplate bean in your Spring configuration class so that it can be injected wherever needed:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Making HTTP Requests with RestTemplate

GET Request

To perform a GET request, you can use the getForObject or getForEntity methods. Here's an example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public String getPost(int id) {
        String url = "https://jsonplaceholder.typicode.com/posts/" + id;
        return restTemplate.getForObject(url, String.class);
    }
}

POST Request

For a POST request, you can use the postForObject or postForEntity methods. Here's how to send a JSON payload:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public String createPost() {
        String url = "https://jsonplaceholder.typicode.com/posts";
        
        Map<String, String> request = new HashMap<>();
        request.put("title", "foo");
        request.put("body", "bar");
        request.put("userId", "1");
        
        return restTemplate.postForObject(url, request, String.class);
    }
}

PUT Request

For updating resources, you can use the put method:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public void updatePost(int id) {
        String url = "https://jsonplaceholder.typicode.com/posts/" + id;
        
        Map<String, String> request = new HashMap<>();
        request.put("title", "updated title");
        request.put("body", "updated body");
        
        restTemplate.put(url, request);
    }
}

DELETE Request

To delete a resource, use the delete method:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public void deletePost(int id) {
        String url = "https://jsonplaceholder.typicode.com/posts/" + id;
        restTemplate.delete(url);
    }
}

Handling Responses

RestTemplate provides several methods to handle responses. The simplest is getForObject, which directly returns the response body. Alternatively, getForEntity returns a ResponseEntity that contains more details, such as the response headers and status code.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RestTemplateService {

    @Autowired
    private RestTemplate restTemplate;

    public ResponseEntity<String> getPostEntity(int id) {
        String url = "https://jsonplaceholder.typicode.com/posts/" + id;
        return restTemplate.getForEntity(url, String.class);
    }
}

Customizing RestTemplate

Timeout Configuration

You can configure timeouts for the underlying HTTP client used by RestTemplate:

import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setReadTimeout(5000);
        factory.setConnectTimeout(5000);
        
        return new RestTemplate(factory);
    }
}

Interceptors

You can add interceptors to manipulate requests and responses:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.util.Collections;

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setInterceptors(Collections.singletonList(new CustomClientHttpRequestInterceptor()));
        return restTemplate;
    }

    class CustomClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            // Modify request here
            ClientHttpResponse response = execution.execute(request, body);
            // Modify response here
            return response;
        }
    }
}

When to Use RestTemplate in Your Java Spring Application

RestTemplate is a well-established utility in the Spring framework, designed to simplify the interaction with RESTful web services. Despite the introduction of WebClient in Spring 5, which offers a more modern, reactive approach, there are still scenarios where RestTemplate remains a viable and sometimes preferable choice. This article discusses when to use RestTemplate in your Java Spring applications.

Scenarios for Using RestTemplate

Simple, Synchronous HTTP Requests

If your application requires simple HTTP requests and responses without the need for advanced features like non-blocking I/O or reactive programming, RestTemplate is an excellent choice. Its synchronous nature and straightforward API make it easy to perform basic HTTP operations.

@Service
public class SimpleRestClientService {
    @Autowired
    private RestTemplate restTemplate;

    public String getSimpleData() {
        String url = "https://api.example.com/data";
        return restTemplate.getForObject(url, String.class);
    }
}

2. Legacy Systems and Existing Codebases

If you are maintaining or extending a legacy system that already uses RestTemplate, it makes sense to continue using it for consistency. Refactoring to WebClient may introduce unnecessary complexity and potential bugs.

3. Applications with Low to Moderate Load

For applications that do not need to handle a large number of simultaneous requests, RestTemplate's synchronous blocking nature is sufficient. It simplifies the codebase without the need for managing asynchronous calls.

@Service
public class ModerateLoadService {
    @Autowired
    private RestTemplate restTemplate;

    public String getModerateLoadData(int id) {
        String url = "https://api.example.com/resource/" + id;
        return restTemplate.getForObject(url, String.class);
    }
}

4. Testing and Prototyping

RestTemplate is ideal for quickly prototyping and testing new features or services. Its simplicity allows for rapid development without the overhead of configuring a more complex client like WebClient.

@RestController
public class PrototypeController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/test")
    public String testEndpoint() {
        String url = "https://jsonplaceholder.typicode.com/posts/1";
        return restTemplate.getForObject(url, String.class);
    }
}

5. Blocking APIs and Third-Party Services

When integrating with third-party services or APIs that are inherently blocking, RestTemplate can be a suitable choice. The nature of these APIs means that using a non-blocking client may not provide significant benefits.

@Service
public class ThirdPartyService {
    @Autowired
    private RestTemplate restTemplate;

    public String getThirdPartyData() {
        String url = "https://thirdparty.api/resource";
        return restTemplate.getForObject(url, String.class);
    }
}

Considerations and Limitations

While RestTemplate is suitable for the scenarios mentioned above, it is important to consider its limitations:

Blocking Nature: RestTemplate is synchronous and blocks the executing thread until the request completes. This can be a drawback for high-throughput or latency-sensitive applications.
Deprecation: With the introduction of WebClient, RestTemplate is no longer the preferred choice for new developments. Spring team recommends using WebClient for non-blocking and reactive applications.
Lack of Advanced Features: RestTemplate lacks some advanced features and flexibility provided by WebClient, such as better handling of non-blocking I/O and reactive streams.

For advantages and disadvantages of RestTemplate, click on this link:https://medium.com/@psdevraye/advantages-and-disadvantages-of-resttemplate-in-java-f647a364f091

Conclusion

RestTemplate is a powerful and easy-to-use tool for interacting with RESTful web services in Spring applications. Its simple API allows for quick integration and handling of HTTP requests and responses. While it has been a go-to solution for many years, it's worth noting that RestTemplate is synchronous and blocking, which may not be ideal for all use cases. For more modern applications requiring non-blocking and reactive programming, consider using WebClient, introduced in Spring 5. Nonetheless, RestTemplate remains a valuable tool for many scenarios in Spring development.

If you found this article helpful, I would be grateful if you could clap and follow me on Medium, Twitter, and LinkedIn. Your support enables me to continue creating content like this. Thank you, and happy coding!

#java #spring #spring-framework #rest-api #interview