RestTemplate: exchange() vs postForEntity() vs execute()

Execute(..) The most raw form of method, to make REST call.

Exchange(..) A wrapper over Execute method.

PostForEntity(..) A wrapper method, which further eases the use for making REST calls. You specify the request type in the method name itself(getForEntity, postForEntity), so, need not mention request type in the parameter. The method name in itself becomes self explanatory.

In Exchange & postForEntity, response has to be in Json formats. This Json is further converted to Model class by json-mapper libraries. While, in Execute, we accept response in any format, as we pass the deserializer in Response Executor argument.

The RestTemplate is a very versatile object.

Let's start with execute, since it's the most generic method:

execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,
        @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)

Note the uriVariables can be passed as a Map too.

execute is designed to be applicable in the highest variety of scenarios possible:

• The first and second parameters allow any valid combination of URL and method.
• The request can be modified in a myriad of different ways by passing a custom RequestCallback (a @FunctionalInterface with just one method doWithRequest(ClientHttpRequest request)) before sending it.
• The response returned from the remote resource can be deserialized in any way necessary by passing a custom ResponseExtractor.

Compare this with exchange:

exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity,
         Class<T> responseType, Object... uriVariables)

There are two major differences here:

• You can now pass an HttpEntity directly, whereas before it needed to be set manually using the RequestCallback.
• Deserialization mechanics are provided out of the box by passing the desired response type Class.

As you can see, this is much more convenient for everyday use.

Methods like getForEntity and postForEntity are even shorter, easier to understand versions of this:

getForEntity(String url, Class<T> responseType, Object... uriVariables)

postForEntity(String url, @Nullable Object request, Class<T> responseType,
              Object... uriVariables)

Notice postForEntity now allows you to POST any Object directly without a wrapper. There is no performance benefit or detriment to using these instead of execute, as they call execute themselves under the hood - it's simply a matter of convenience.

RestTemplate is a synchronous client to perform HTTP requests. It offers templates for common scenarios for each HTTP method, in addition to the generalized exchange(...) and execute(...) methods that support less frequent cases.

The Spring Integration documentation summarizes the usage of each method:

postForEntity

Create a new resource via POST and return the representation from the response.

exchange

More generalized, and less opinionated version, of the above methods that provides extra flexibility when needed. It accepts RequestEntity, including HTTP method, URL, headers, and body as input, and returns a ResponseEntity.

These methods allow the use of ParameterizedTypeReference instead of Class to specify a response type with generics.

execute

The most generalized way to perform a request, with full control over request preparation and response extraction via callback interfaces.

---

In the end, both postForEntity(...), exchange(...) and execute(...) methods will invoke the protected doExecute(...) method, which will perform the actual HTTP request. You can check the source code for details