The use of the Spring RestTemplate client is very common in microservices architectures or when calling other applications. In this post, we will see how we can create an interceptor in RestTemplate by adding headers to a REST request.

What is RestTemplate?

RestTemplate is a class provided by Spring Boot that simplifies making HTTP requests to external REST APIs. It provides a convenient way to interact with RESTful services by abstracting the complexities of creating and managing HTTP connections. Handling request and response serialization, and managing error handling.

RestTemplate supports various HTTP methods such as GET, POST, PUT, DELETE, etc. RestTemplate allows customization of headers, query parameters, and request/response bodies. However, starting from Spring 5, RestTemplate is in maintenance mode, and WebClient is recommended for new projects due to its non-blocking and reactive nature.

What is an interceptor in programming?

An interceptor in programming is a component or mechanism that allows capturing and manipulating requests and responses in an application. It acts as a filter or middleware between the client and the server, intercepting the calls and performing additional actions before or after they are processed.

In Spring, we can apply interceptors to perform tasks such as authentication and authorization, request logging, adding headers, caching, etc.

Creating an Interceptor for RestTemplate in Spring

To create an interceptor, Spring provides the ClientHttpRequestInterceptor class, which provides an interface to implement.

Let’s start by creating a class that implements ClientHttpRequestInterceptor:

public class HeaderTraceInterceptor
  implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(
      HttpRequest request, 
      byte[] body, 
      ClientHttpRequestExecution execution) throws IOException {
 
        ClientHttpResponse response = execution.execute(request, body);
        response.getHeaders().add("Trace", "myTrace");
        return response;
    }
}

In the above code, we have added an interceptor so that every time a restTemplate request is made, we add a “Trace” header with the value “myTrace” to the response.

If, on the other hand, we want to add that header to the request with each request, we can do the following:

public class HeaderTraceInterceptor
  implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(
      HttpRequest request, 
      byte[] body, 
      ClientHttpRequestExecution execution) throws IOException {
         request.getHeaders().set("trace", "myTrace");

		
	return execution.execute(request, body);
    }
}

Adding the Interceptor to RestTemplate

Once we have created our HeaderTraceInterceptor, we need to add it to the RestTemplate configuration.

@Configuration
public class RestClientConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();

        List<ClientHttpRequestInterceptor> interceptors
          = restTemplate.getInterceptors();
        if (CollectionUtils.isEmpty(interceptors)) {
            interceptors = new ArrayList<>();
        }
        interceptors.add(new HeaderTraceInterceptor());
        restTemplate.setInterceptors(interceptors);
        return restTemplate;
    }
}

With the above configuration, we have added our interceptor to the configuration of our RestTemplate. We retrieve the interceptors that our RestTemplate may have and add ours.

Conclusion

In this post, we have seen how to create an interceptor in RestTemplate in a fairly simple and easy way.

The use of interceptors in RestTemplate is often necessary when dealing with security issues to propagate context or when we want to propagate a trace header. For example, something similar to what Sleuth does.