current community

your communities

more stack exchange communities

Stack Exchange
tour help
Take the 2-minute tour ×
Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.
up vote 1 down vote favorite

I am using RestTemplate to make an Http call to one of my service and I would like to have timeout for my Http Request -

public static String getResponse(final String url) {

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

    // return response

}

private ClientHttpRequestFactory clientHttpRequestFactory() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setReadTimeout(2000);
    factory.setConnectTimeout(2000);
    return factory;
}

So I came up with the above code after reading this How to Set HTTP Request Timeouts With Spring RestTemplate.

Is this the efficient way of using RestTemplate along with ClientHttpRequestFactory? Since with this for each call, it will make a new RestTemplate object. Earlier, I was not using any timeout for RestTemplate so I declared RestTemplate as static final and below was my code -

private static final RestTemplate restTemplate = new RestTemplate();

public static String getResponse(final String url) {

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

    // return response

}

I am not sure what is the right way of using RestTemplate along with ClientHttpRequestFactory. Should they both be declared as static? I am opting for code review to see whether there is any improvement I can do here?

share|improve this question

1 Answer 1

up vote 1 down vote accepted

In the example you linked, RestTemplate is annotated with @Bean:

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

Beans are (normally) singletons in Spring, intended for reuse. This related post also confirms that RestTemplate is thread-safe, and it would be wasteful to recreate it every time.

It would be best to configure RestTemplate as in the linked article, and inject into your setup using Spring's annotations based configuration. Or, you could make it a private final member of your class.

class RequestHandler {
    private final RestTemplate restTemplate;

    public RequestHandler() {
        restTemplate = new RestTemplate(clientHttpRequestFactory());
    }

    public RestTemplate getRestTemplate() {
        return restTemplate;
    }
}
share|improve this answer
    
Thanks for explanation. I don't need to use inject in my code using Spring annotations. How can I normally use it as private final member in my class along with ClientHttpRequestFactory corresponding to my examplle? –  lining Sep 6 '14 at 6:58
    
I don't understand what you don't understand about private final member variables. I added an example just in case. –  janos Sep 6 '14 at 7:20
    
Thanks janos. What I meant was, I didn't wanted to use any bean annotations in my code. In your example, I should be having clientHttpRequestFactory() method in same RequestHandler class right? And also how will I get the instance of RestTemplate from RequestHandler class? –  lining Sep 6 '14 at 7:48
    
I meant that restTemplate should be a member in the same class as your getResponse method. Since you haven't shared your class structure, it's hard to be more specific. I believe your main question was if it's better to reuse a RestTemplate than recreate. Yes it is. When you say you don't want to use bean annotations in your code, I'm getting the feeling that maybe you don't know how to use spring correctly to configure your application. Maybe you're not enjoying all the benefits Spring can bring to you. But that discussion doesn't belong in this question. –  janos Sep 6 '14 at 8:56

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.