Spring RestTemplate timeout

For Spring Boot >= 1.4

@Configuration public class AppConfig { @Bean public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) { return restTemplateBuilder .setConnectTimeout(...) .setReadTimeout(...) .build(); } } 

For Spring Boot <= 1.3

@Configuration public class AppConfig { @Bean @ConfigurationProperties(prefix = "custom.rest.connection") public HttpComponentsClientHttpRequestFactory customHttpRequestFactory() { return new HttpComponentsClientHttpRequestFactory(); } @Bean public RestTemplate customRestTemplate() { return new RestTemplate(customHttpRequestFactory()); } } 

then in your application.properties

custom.rest.connection.connection-request-timeout=... custom.rest.connection.connect-timeout=... custom.rest.connection.read-timeout=... 

This works because HttpComponentsClientHttpRequestFactory has public setters connectionRequestTimeout, connectTimeout, and readTimeout and @ConfigurationProperties sets them for you.

For Spring 4.1 or Spring 5 without Spring Boot using @Configuration instead of XML

@Configuration public class AppConfig { @Bean public RestTemplate customRestTemplate() { HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory(); httpRequestFactory.setConnectionRequestTimeout(...); httpRequestFactory.setConnectTimeout(...); httpRequestFactory.setReadTimeout(...); return new RestTemplate(httpRequestFactory); } } 

This question is the first link for a Spring Boot search, therefore, would be great to put here the solution recommended in the official documentation. Spring Boot has its own convenience bean RestTemplateBuilder:

@Bean public RestTemplate restTemplate( RestTemplateBuilder restTemplateBuilder) { return restTemplateBuilder .setConnectTimeout(Duration.ofSeconds(500)) .setReadTimeout(Duration.ofSeconds(500)) .build(); } 

Manual creation of RestTemplate instances is a potentially troublesome approach because other auto-configured beans are not being injected in manually created instances.

Here are my 2 cents. Nothing new, but some explanations, improvements and newer code.

By default, RestTemplate has infinite timeout. There are two kinds of timeouts: connection timeout and read time out. For instance, I could connect to the server but I could not read data. The application was hanging and you have no clue what's going on.

I am going to use annotations, which these days are preferred over XML.

@Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { var factory = new SimpleClientHttpRequestFactory(); factory.setConnectTimeout(3000); factory.setReadTimeout(3000); return new RestTemplate(factory); } } 

Here we use SimpleClientHttpRequestFactory to set the connection and read time outs. It is then passed to the constructor of RestTemplate.

@Configuration public class AppConfig { @Bean public RestTemplate restTemplate(RestTemplateBuilder builder) { return builder .setConnectTimeout(Duration.ofMillis(3000)) .setReadTimeout(Duration.ofMillis(3000)) .build(); } } 

In the second solution, we use the RestTemplateBuilder. Also notice the parameters of the two methods: they take Duration. The overloaded methods that take directly milliseconds are now deprecated.

Edit Tested with Spring Boot 2.1.0 and Java 11.

Here is a really simple way to set the timeout:

RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory()); private ClientHttpRequestFactory getClientHttpRequestFactory() { int timeout = 5000; HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(); clientHttpRequestFactory.setConnectTimeout(timeout); return clientHttpRequestFactory; } 

1. RestTemplate timeout with SimpleClientHttpRequestFactory To programmatically override the timeout properties, we can customize the SimpleClientHttpRequestFactory class as below.

Override timeout with SimpleClientHttpRequestFactory

//Create resttemplate RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory()); //Override timeouts in request factory private SimpleClientHttpRequestFactory getClientHttpRequestFactory() { SimpleClientHttpRequestFactory clientHttpRequestFactory = new SimpleClientHttpRequestFactory(); //Connect timeout clientHttpRequestFactory.setConnectTimeout(10_000); //Read timeout clientHttpRequestFactory.setReadTimeout(10_000); return clientHttpRequestFactory; } 

2. RestTemplate timeout with HttpComponentsClientHttpRequestFactory SimpleClientHttpRequestFactory helps in setting timeout but it is very limited in functionality and may not prove sufficient in realtime applications. In production code, we may want to use HttpComponentsClientHttpRequestFactory which support HTTP Client library along with resttemplate.

HTTPClient provides other useful features such as connection pool, idle connection management etc.

Read More : Spring RestTemplate + HttpClient configuration example

Override timeout with HttpComponentsClientHttpRequestFactory

//Create resttemplate RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory()); //Override timeouts in request factory private SimpleClientHttpRequestFactory getClientHttpRequestFactory() { HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(); //Connect timeout clientHttpRequestFactory.setConnectTimeout(10_000); //Read timeout clientHttpRequestFactory.setReadTimeout(10_000); return clientHttpRequestFactory; } 

reference: Spring RestTemplate timeout configuration example

SpringBoot version >2

Simple timeout for restTemplate.I have set the read and write timeout for 3 seconds.

@Bean public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){ RestTemplate restTemplate= restTemplateBuilder.setConnectTimeout(Duration.ofMillis(3000)).setReadTimeout(Duration.ofMillis(3000)).build(); return restTemplate; } 

If you want to set dynamic timeout values. Kindly refer below.

 //basic imports @SpringBootApplication public class DemoApplication{ //the below values are injected from application.properties file @Value($"{connection.timeout.value}") private String connectionTimeoutValue; @Value("${read.timeout.value}") private String readTimeOutValue; public static void main(String args[]){ SpringApplication.run(DemoApplication.class, args) } @Bean public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder){ RestTemplate restTemplate= restTemplateBuilder.setConnectTimeout(Duration.ofMillis(connectionTimeoutValue)).setReadTimeout(Duration.ofMillis(readTimeOutValue)).build(); return restTemplate; } } 

Inside the application.properties file:

#change the numerical values according to your need. connection.timeout.value=3000 read.timeout.value=3000 

NOTE:Timeout values are in milliseconds.

for SpringBoot version<2: kindly remove the Duration.ofMillis and provide the values directly like below...

RestTemplate restTemplate= restTemplateBuilder.setConnectTimeout(3000).setReadTimeout(3000).build(); 

The current version of Springboot (3.0.X), using org.apache.hc.client5.http.CloseableHttpClient should look something like this

 private CloseableHttpClient httpClient() { Timeout connectionRequestTimeout = Timeout.ofSeconds(WHATEVER_YOU_NEED); Timeout responseTimeout = Timeout.ofSeconds(YET_AGAIN_WHATEVER_YOU_NEED); RequestConfig requestConfig = RequestConfig.custom() .setConnectionRequestTimeout(connectionRequestTimeout) .setResponseTimeout(responseTimeout) .build(); return HttpClients.custom() .setDefaultRequestConfig(requestConfig) .build(); } 

Your CloseableHttpClient should then be used to create a request factory, which in turn should be used to create a rest template.

In the snipet above:

• The connectionRequestTimeout is a configuration setting that specifies the maximum amount of time to wait for a connection from the connection manager
• This is different from responseTimeout (or socketTimeout in the older versions of HttpClient), which sets the maximum inactivity period between two consecutive data packets when waiting for the server's response.

Please note that this example is simplistic. If you're using this kind of Appache HttpClient, it's probably because you want to add more stuff to it and not just the timeout.

Setting the timeout only in RestTemplateBuilder didn't work for me when i was using Apache's httpcomponents. I had to set the timeout in the RequestFactory as well.

Here's the entire code:

public RestTemplate templateBuilder() { RestTemplate restTemplate = this.restTemplateBuilder .setConnectTimeout(Duration.ofSeconds(connectTimeout)) .setReadTimeout(Duration.ofSeconds(readTimeout)) .build(); HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(); requestFactory.setConnectTimeout((int) connectTimeout * 1000); requestFactory.setReadTimeout((int) readTimeout * 1000); requestFactory.setConnectionRequestTimeout((int) connectTimeout * 1000); restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(requestFactory)); return restTemplate; } 

I had a similar scenario, but was also required to set a Proxy. The simplest way I could see to do this was to extend the SimpleClientHttpRequestFactory for the ease of setting the proxy (different proxies for non-prod vs prod). This should still work even if you don't require the proxy though. Then in my extended class I override the openConnection(URL url, Proxy proxy) method, using the same as the source, but just setting the timeouts before returning.

@Override protected HttpURLConnection openConnection(URL url, Proxy proxy) throws IOException { URLConnection urlConnection = proxy != null ? url.openConnection(proxy) : url.openConnection(); Assert.isInstanceOf(HttpURLConnection.class, urlConnection); urlConnection.setConnectTimeout(5000); urlConnection.setReadTimeout(5000); return (HttpURLConnection) urlConnection; } 

To expand on benscabbia's answer:

private RestTemplate restCaller = new RestTemplate(getClientHttpRequestFactory()); private ClientHttpRequestFactory getClientHttpRequestFactory() { int connectionTimeout = 5000; // milliseconds int socketTimeout = 10000; // milliseconds RequestConfig config = RequestConfig.custom() .setConnectTimeout(connectionTimeout) .setConnectionRequestTimeout(connectionTimeout) .setSocketTimeout(socketTimeout) .build(); CloseableHttpClient client = HttpClientBuilder .create() .setDefaultRequestConfig(config) .build(); return new HttpComponentsClientHttpRequestFactory(client); } 

private static RestTemplate restTemplate; static { HttpComponentsClientHttpRequestFactory rf = new HttpComponentsClientHttpRequestFactory(); rf.setReadTimeout(3 * 1000); rf.setConnectTimeout(2 * 1000); restTemplate = new RestTemplate(rf); restTemplate.getMessageConverters() .add(0, new StringHttpMessageConverter(StandardCharsets.UTF_8)); } 

By default, RestTemplate uses SimpleClientHttpRequestFactory which depends on the default configuration of HttpURLConnection. Look inside the class source, and you will find this

private int connectTimeout = -1; private int readTimeout = -1; 

By default, RestTemplate uses the timeout property from JDK installed on the machine which is always infinite if not overridden. To override the default JVM timeout, we can pass these properties during the JVM start. The time unit is in milliseconds.

Override default timeout in JVM

-Dsun.net.client.defaultConnectTimeout=5000 -Dsun.net.client.defaultReadTimeout=5000