org.springframework.web.client

## Class RestTemplate

- java.lang.Object
- - org.springframework.http.client.support.HttpAccessor
  - - org.springframework.http.client.support.InterceptingHttpAccessor
    - - org.springframework.web.client.RestTemplate

All Implemented Interfaces:
  RestOperations

    public class RestTemplate
    extends InterceptingHttpAccessor
    implements RestOperations

The central class for client-side HTTP access. It simplifies communication with HTTP servers, and enforces RESTful principles. It handles HTTP connections, leaving application code to provide URLs (with possible template variables) and extract results.

The main entry points of this template are the methods named after the six main HTTP methods:

HTTP method | RestTemplate methods
--- | ---
DELETE | `delete(java.lang.String, java.lang.Object...)`
GET | `getForObject(java.lang.String, java.lang.Class<T>, java.lang.Object...)`
| `getForEntity(java.lang.String, java.lang.Class<T>, java.lang.Object...)`
HEAD | `headForHeaders(java.lang.String, java.lang.Object...)`
OPTIONS | `optionsForAllow(java.lang.String, java.lang.Object...)`
POST | `postForLocation(java.lang.String, java.lang.Object, java.lang.Object...)`
| `postForObject(java.lang.String, java.lang.Object, java.lang.Class<T>, java.lang.Object...)`
PUT | `put(java.lang.String, java.lang.Object, java.lang.Object...)`
any | `exchange(java.lang.String, org.springframework.http.HttpMethod, org.springframework.http.HttpEntity<?>, java.lang.Class<T>, java.lang.Object...)`
| `execute(java.lang.String, org.springframework.http.HttpMethod, org.springframework.web.client.RequestCallback, org.springframework.web.client.ResponseExtractor<T>, java.lang.Object...)`

The `exchange` and `execute` methods are generalized versions of the more specific methods listed above them. They support additional, less frequently used combinations including support for requests using the HTTP PATCH method. However, note that the underlying HTTP library must also support the desired combination.

For each of these HTTP methods, there are three corresponding Java methods in the `RestTemplate`. Two variant take a `String` URI as first argument (eg. `getForObject(String, Class, Object[])`, `getForObject(String, Class, Map)`), and are capable of substituting any URI templates in that URL using either a `String` variable arguments array, or a `Map<String, String>`. The string varargs variant expands the given template variables in order, so that

     String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/bookings/{booking}", String.class,"42",
     "21");

will perform a GET on `http://example.com/hotels/42/bookings/21`. The map variant expands the template based on variable name, and is therefore more useful when using many variables, or when a single variable is used multiple times. For example:

     Map<String, String> vars = Collections.singletonMap("hotel", "42");
     String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/rooms/{hotel}", String.class, vars);

will perform a GET on `http://example.com/hotels/42/rooms/42`. Alternatively, there are `URI` variant methods (`getForObject(URI, Class)`), which do not allow for URI templates, but allow you to reuse a single, expanded URI multiple times.

Furthermore, the `String`-argument methods assume that the URL String is unencoded. This means that

     restTemplate.getForObject("http://example.com/hotel list");

will perform a GET on `http://example.com/hotel%20list`. As a result, any URL passed that is already encoded will be encoded twice (i.e. `http://example.com/hotel%20list` will become `http://example.com/hotel%2520list`). If this behavior is undesirable, use the `URI`-argument methods, which will not perform any URL encoding.

Objects passed to and returned from these methods are converted to and from HTTP messages by `HttpMessageConverter` instances. Converters for the main mime types are registered by default, but you can also write your own converter and register it via the `messageConverters` bean property.

This template uses a `SimpleClientHttpRequestFactory` and a `DefaultResponseErrorHandler` as default strategies for creating HTTP connections or handling HTTP errors, respectively. These defaults can be overridden through the `requestFactory` and `errorHandler` bean properties.

Since:
  3.0
Author:
  Arjen Poutsma
See Also:
  `HttpMessageConverter`, `RequestCallback`, `ResponseExtractor`, `ResponseErrorHandler`

### Field Summary

### Fields inherited from class org.springframework.http.client.support.HttpAccessor

`logger`

### Constructor Summary

Constructors
Constructor and Description
`RestTemplate()` Create a new instance of the `RestTemplate` using default settings.
`RestTemplate(ClientHttpRequestFactory requestFactory)` Create a new instance of the `RestTemplate` based on the given `ClientHttpRequestFactory`.

### Method Summary

Methods
`void` `delete(String url, Map<String,?> urlVariables)` Delete the resources at the specified URI.
`void` `delete(String url, Object... urlVariables)` Delete the resources at the specified URI.
`void` `delete(URI url)` Delete the resources at the specified URL.
`protected <T> T` `doExecute(URI url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor)` Execute the given method on the provided URI.
`<T> ResponseEntity<T>` `exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String,?> uriVariables)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String,?> uriVariables)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)` Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.
`<T> T` `execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Map<String,?> urlVariables)` Execute the HTTP method to the given URI template, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.
`<T> T` `execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables)` Execute the HTTP method to the given URI template, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.
`<T> T` `execute(URI url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor)` Execute the HTTP method to the given URL, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.
`ResponseErrorHandler` `getErrorHandler()` Return the error handler.
`<T> ResponseEntity<T>` `getForEntity(String url, Class<T> responseType, Map<String,?> urlVariables)` Retrieve a representation by doing a GET on the URI template.
`<T> ResponseEntity<T>` `getForEntity(String url, Class<T> responseType, Object... urlVariables)` Retrieve an entity by doing a GET on the specified URL.
`<T> ResponseEntity<T>` `getForEntity(URI url, Class<T> responseType)` Retrieve a representation by doing a GET on the URL .
`<T> T` `getForObject(String url, Class<T> responseType, Map<String,?> urlVariables)` Retrieve a representation by doing a GET on the URI template.
`<T> T` `getForObject(String url, Class<T> responseType, Object... urlVariables)` Retrieve a representation by doing a GET on the specified URL.
`<T> T` `getForObject(URI url, Class<T> responseType)` Retrieve a representation by doing a GET on the URL .
`List<HttpMessageConverter<?>>` `getMessageConverters()` Returns the message body converters.
`HttpHeaders` `headForHeaders(String url, Map<String,?> urlVariables)` Retrieve all headers of the resource specified by the URI template.
`HttpHeaders` `headForHeaders(String url, Object... urlVariables)` Retrieve all headers of the resource specified by the URI template.
`HttpHeaders` `headForHeaders(URI url)` Retrieve all headers of the resource specified by the URL.
`Set<HttpMethod>` `optionsForAllow(String url, Map<String,?> urlVariables)` Return the value of the Allow header for the given URI.
`Set<HttpMethod>` `optionsForAllow(String url, Object... urlVariables)` Return the value of the Allow header for the given URI.
`Set<HttpMethod>` `optionsForAllow(URI url)` Return the value of the Allow header for the given URL.
`<T> ResponseEntity<T>` `postForEntity(String url, Object request, Class<T> responseType, Map<String,?> uriVariables)` Create a new resource by POSTing the given object to the URI template, and returns the response as `HttpEntity`.
`<T> ResponseEntity<T>` `postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables)` Create a new resource by POSTing the given object to the URI template, and returns the response as `ResponseEntity`.
`<T> ResponseEntity<T>` `postForEntity(URI url, Object request, Class<T> responseType)` Create a new resource by POSTing the given object to the URL, and returns the response as `ResponseEntity`.
`URI` `postForLocation(String url, Object request, Map<String,?> urlVariables)` Create a new resource by POSTing the given object to the URI template, and returns the value of the `Location` header.
`URI` `postForLocation(String url, Object request, Object... urlVariables)` Create a new resource by POSTing the given object to the URI template, and returns the value of the `Location` header.
`URI` `postForLocation(URI url, Object request)` Create a new resource by POSTing the given object to the URL, and returns the value of the `Location` header.
`<T> T` `postForObject(String url, Object request, Class<T> responseType, Map<String,?> uriVariables)` Create a new resource by POSTing the given object to the URI template, and returns the representation found in the response.
`<T> T` `postForObject(String url, Object request, Class<T> responseType, Object... uriVariables)` Create a new resource by POSTing the given object to the URI template, and returns the representation found in the response.
`<T> T` `postForObject(URI url, Object request, Class<T> responseType)` Create a new resource by POSTing the given object to the URL, and returns the representation found in the response.
`void` `put(String url, Object request, Map<String,?> urlVariables)` Creates a new resource by PUTting the given object to URI template.
`void` `put(String url, Object request, Object... urlVariables)` Create or update a resource by PUTting the given object to the URI.
`void` `put(URI url, Object request)` Creates a new resource by PUTting the given object to URL.
`void` `setErrorHandler(ResponseErrorHandler errorHandler)` Set the error handler.
`void` `setMessageConverters(List<HttpMessageConverter<?>> messageConverters)` Set the message body converters to use.

### Methods inherited from class org.springframework.http.client.support.InterceptingHttpAccessor

`getInterceptors, getRequestFactory, setInterceptors`

### Methods inherited from class org.springframework.http.client.support.HttpAccessor

`createRequest, setRequestFactory`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### RestTemplate

    public RestTemplate()

Create a new instance of the `RestTemplate` using default settings.

#### RestTemplate

    public RestTemplate(ClientHttpRequestFactory requestFactory)

Create a new instance of the `RestTemplate` based on the given `ClientHttpRequestFactory`.

Parameters:
  `requestFactory` - HTTP request factory to use
See Also:
  `SimpleClientHttpRequestFactory`, `CommonsClientHttpRequestFactory`

### Method Detail

#### setMessageConverters

    public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)

Set the message body converters to use. These converters are used to convert from and to HTTP requests and responses.

#### getMessageConverters

    public List<HttpMessageConverter<?>> getMessageConverters()

Returns the message body converters. These converters are used to convert from and to HTTP requests and responses.

#### setErrorHandler

    public void setErrorHandler(ResponseErrorHandler errorHandler)

Set the error handler.

#### getErrorHandler

    public ResponseErrorHandler getErrorHandler()

Return the error handler. By default, this is the `DefaultResponseErrorHandler`.

#### getForObject

    public <T> T getForObject(String url,
                     Class<T> responseType,
                     Object... urlVariables)
                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve a representation by doing a GET on the specified URL. The response (if any) is converted and returned.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `getForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
  `urlVariables` - the variables to expand the template
Returns:
  the converted object
Throws:
  `RestClientException`

#### getForObject

    public <T> T getForObject(String url,
                     Class<T> responseType,
                     Map<String,?> urlVariables)
                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve a representation by doing a GET on the URI template. The response (if any) is converted and returned.

URI Template variables are expanded using the given map.

Specified by:
  `getForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
  `urlVariables` - the map containing variables for the URI template
Returns:
  the converted object
Throws:
  `RestClientException`

#### getForObject

    public <T> T getForObject(URI url,
                     Class<T> responseType)
                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve a representation by doing a GET on the URL . The response (if any) is converted and returned.

Specified by:
  `getForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
Returns:
  the converted object
Throws:
  `RestClientException`

#### getForEntity

    public <T> ResponseEntity<T> getForEntity(String url,
                                     Class<T> responseType,
                                     Object... urlVariables)
                                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve an entity by doing a GET on the specified URL. The response is converted and stored in an `ResponseEntity`.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `getForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
  `urlVariables` - the variables to expand the template
Returns:
  the entity
Throws:
  `RestClientException`

#### getForEntity

    public <T> ResponseEntity<T> getForEntity(String url,
                                     Class<T> responseType,
                                     Map<String,?> urlVariables)
                                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve a representation by doing a GET on the URI template. The response is converted and stored in an `ResponseEntity`.

URI Template variables are expanded using the given map.

Specified by:
  `getForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
  `urlVariables` - the map containing variables for the URI template
Returns:
  the converted object
Throws:
  `RestClientException`

#### getForEntity

    public <T> ResponseEntity<T> getForEntity(URI url,
                                     Class<T> responseType)
                                   throws RestClientException

Description copied from interface: `RestOperations`
Retrieve a representation by doing a GET on the URL . The response is converted and stored in an `ResponseEntity`.

Specified by:
  `getForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `responseType` - the type of the return value
Returns:
  the converted object
Throws:
  `RestClientException`

#### headForHeaders

    public HttpHeaders headForHeaders(String url,
                             Object... urlVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Retrieve all headers of the resource specified by the URI template.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `headForHeaders` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the variables to expand the template
Returns:
  all HTTP headers of that resource
Throws:
  `RestClientException`

#### headForHeaders

    public HttpHeaders headForHeaders(String url,
                             Map<String,?> urlVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Retrieve all headers of the resource specified by the URI template.

URI Template variables are expanded using the given map.

Specified by:
  `headForHeaders` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the map containing variables for the URI template
Returns:
  all HTTP headers of that resource
Throws:
  `RestClientException`

#### headForHeaders

    public HttpHeaders headForHeaders(URI url)
                               throws RestClientException

Description copied from interface: `RestOperations`
Retrieve all headers of the resource specified by the URL.

Specified by:
  `headForHeaders` in interface `RestOperations`
Parameters:
  `url` - the URL
Returns:
  all HTTP headers of that resource
Throws:
  `RestClientException`

#### postForLocation

    public URI postForLocation(String url,
                      Object request,
                      Object... urlVariables)
                        throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the value of the `Location` header. This header typically indicates where the new resource is stored.

URI Template variables are expanded using the given URI variables, if any.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForLocation` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `urlVariables` - the variables to expand the template
Returns:
  the value for the `Location` header
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForLocation

    public URI postForLocation(String url,
                      Object request,
                      Map<String,?> urlVariables)
                        throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the value of the `Location` header. This header typically indicates where the new resource is stored.

URI Template variables are expanded using the given map.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForLocation` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `urlVariables` - the variables to expand the template
Returns:
  the value for the `Location` header
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForLocation

    public URI postForLocation(URI url,
                      Object request)
                        throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URL, and returns the value of the `Location` header. This header typically indicates where the new resource is stored.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForLocation` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
Returns:
  the value for the `Location` header
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForObject

    public <T> T postForObject(String url,
                      Object request,
                      Class<T> responseType,
                      Object... uriVariables)
                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the representation found in the response.

URI Template variables are expanded using the given URI variables, if any.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand the template
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForObject

    public <T> T postForObject(String url,
                      Object request,
                      Class<T> responseType,
                      Map<String,?> uriVariables)
                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the representation found in the response.

URI Template variables are expanded using the given map.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand the template
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForObject

    public <T> T postForObject(URI url,
                      Object request,
                      Class<T> responseType)
                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URL, and returns the representation found in the response.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForObject` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `responseType` - the type of the return value
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForEntity

    public <T> ResponseEntity<T> postForEntity(String url,
                                      Object request,
                                      Class<T> responseType,
                                      Object... uriVariables)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the response as `ResponseEntity`.

URI Template variables are expanded using the given URI variables, if any.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `uriVariables` - the variables to expand the template
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForEntity

    public <T> ResponseEntity<T> postForEntity(String url,
                                      Object request,
                                      Class<T> responseType,
                                      Map<String,?> uriVariables)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URI template, and returns the response as `HttpEntity`.

URI Template variables are expanded using the given map.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
  `uriVariables` - the variables to expand the template
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### postForEntity

    public <T> ResponseEntity<T> postForEntity(URI url,
                                      Object request,
                                      Class<T> responseType)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Create a new resource by POSTing the given object to the URL, and returns the response as `ResponseEntity`.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `postForEntity` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be POSTed, may be `null`
Returns:
  the converted object
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### put

    public void put(String url,
           Object request,
           Object... urlVariables)
             throws RestClientException

Description copied from interface: `RestOperations`
Create or update a resource by PUTting the given object to the URI.

URI Template variables are expanded using the given URI variables, if any.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `put` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be PUT, may be `null`
  `urlVariables` - the variables to expand the template
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### put

    public void put(String url,
           Object request,
           Map<String,?> urlVariables)
             throws RestClientException

Description copied from interface: `RestOperations`
Creates a new resource by PUTting the given object to URI template.

URI Template variables are expanded using the given map.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `put` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be PUT, may be `null`
  `urlVariables` - the variables to expand the template
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### put

    public void put(URI url,
           Object request)
             throws RestClientException

Description copied from interface: `RestOperations`
Creates a new resource by PUTting the given object to URL.

The `request` parameter can be a `HttpEntity` in order to add additional HTTP headers to the request.

Specified by:
  `put` in interface `RestOperations`
Parameters:
  `url` - the URL
  `request` - the Object to be PUT, may be `null`
Throws:
  `RestClientException`
See Also:
  `HttpEntity`

#### delete

    public void delete(String url,
              Object... urlVariables)
                throws RestClientException

Description copied from interface: `RestOperations`
Delete the resources at the specified URI.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `delete` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the variables to expand in the template
Throws:
  `RestClientException`

#### delete

    public void delete(String url,
              Map<String,?> urlVariables)
                throws RestClientException

Description copied from interface: `RestOperations`
Delete the resources at the specified URI.

URI Template variables are expanded using the given map.

Specified by:
  `delete` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the variables to expand the template
Throws:
  `RestClientException`

#### delete

    public void delete(URI url)
                throws RestClientException

Description copied from interface: `RestOperations`
Delete the resources at the specified URL.

Specified by:
  `delete` in interface `RestOperations`
Parameters:
  `url` - the URL
Throws:
  `RestClientException`

#### optionsForAllow

    public Set<HttpMethod> optionsForAllow(String url,
                                  Object... urlVariables)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Return the value of the Allow header for the given URI.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `optionsForAllow` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the variables to expand in the template
Returns:
  the value of the allow header
Throws:
  `RestClientException`

#### optionsForAllow

    public Set<HttpMethod> optionsForAllow(String url,
                                  Map<String,?> urlVariables)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Return the value of the Allow header for the given URI.

URI Template variables are expanded using the given map.

Specified by:
  `optionsForAllow` in interface `RestOperations`
Parameters:
  `url` - the URL
  `urlVariables` - the variables to expand in the template
Returns:
  the value of the allow header
Throws:
  `RestClientException`

#### optionsForAllow

    public Set<HttpMethod> optionsForAllow(URI url)
                                    throws RestClientException

Description copied from interface: `RestOperations`
Return the value of the Allow header for the given URL.

Specified by:
  `optionsForAllow` in interface `RestOperations`
Parameters:
  `url` - the URL
Returns:
  the value of the allow header
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(String url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 Class<T> responseType,
                                 Object... uriVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand in the template
Returns:
  the response as entity
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(String url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 Class<T> responseType,
                                 Map<String,?> uriVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand in the template
Returns:
  the response as entity
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(URI url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 Class<T> responseType)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`.

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
Returns:
  the response as entity
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(String url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 ParameterizedTypeReference<T> responseType,
                                 Object... uriVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`. The given `ParameterizedTypeReference` is used to pass generic type information:

     ParameterizedTypeReference<List<MyBean>> myBean = new ParameterizedTypeReference<List<MyBean>>() {};
     ResponseEntity<List<MyBean>> response = template.exchange("http://example.com",HttpMethod.GET, null, myBean);

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand in the template
Returns:
  the response as entity
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(String url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 ParameterizedTypeReference<T> responseType,
                                 Map<String,?> uriVariables)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`. The given `ParameterizedTypeReference` is used to pass generic type information:

     ParameterizedTypeReference<List<MyBean>> myBean = new ParameterizedTypeReference<List<MyBean>>() {};
     ResponseEntity<List<MyBean>> response = template.exchange("http://example.com",HttpMethod.GET, null, myBean);

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
  `uriVariables` - the variables to expand in the template
Returns:
  the response as entity
Throws:
  `RestClientException`

#### exchange

    public <T> ResponseEntity<T> exchange(URI url,
                                 HttpMethod method,
                                 HttpEntity<?> requestEntity,
                                 ParameterizedTypeReference<T> responseType)
                               throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, writing the given request entity to the request, and returns the response as `ResponseEntity`. The given `ParameterizedTypeReference` is used to pass generic type information:

     ParameterizedTypeReference<List<MyBean>> myBean = new ParameterizedTypeReference<List<MyBean>>() {};
     ResponseEntity<List<MyBean>> response = template.exchange("http://example.com",HttpMethod.GET, null, myBean);

Specified by:
  `exchange` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestEntity` - the entity (headers and/or body) to write to the request, may be `null`
  `responseType` - the type of the return value
Returns:
  the response as entity
Throws:
  `RestClientException`

#### execute

    public <T> T execute(String url,
                HttpMethod method,
                RequestCallback requestCallback,
                ResponseExtractor<T> responseExtractor,
                Object... urlVariables)
              throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.

URI Template variables are expanded using the given URI variables, if any.

Specified by:
  `execute` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestCallback` - object that prepares the request
  `responseExtractor` - object that extracts the return value from the response
  `urlVariables` - the variables to expand in the template
Returns:
  an arbitrary object, as returned by the `ResponseExtractor`
Throws:
  `RestClientException`

#### execute

    public <T> T execute(String url,
                HttpMethod method,
                RequestCallback requestCallback,
                ResponseExtractor<T> responseExtractor,
                Map<String,?> urlVariables)
              throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URI template, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.

URI Template variables are expanded using the given URI variables map.

Specified by:
  `execute` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestCallback` - object that prepares the request
  `responseExtractor` - object that extracts the return value from the response
  `urlVariables` - the variables to expand in the template
Returns:
  an arbitrary object, as returned by the `ResponseExtractor`
Throws:
  `RestClientException`

#### execute

    public <T> T execute(URI url,
                HttpMethod method,
                RequestCallback requestCallback,
                ResponseExtractor<T> responseExtractor)
              throws RestClientException

Description copied from interface: `RestOperations`
Execute the HTTP method to the given URL, preparing the request with the `RequestCallback`, and reading the response with a `ResponseExtractor`.

Specified by:
  `execute` in interface `RestOperations`
Parameters:
  `url` - the URL
  `method` - the HTTP method (GET, POST, etc)
  `requestCallback` - object that prepares the request
  `responseExtractor` - object that extracts the return value from the response
Returns:
  an arbitrary object, as returned by the `ResponseExtractor`
Throws:
  `RestClientException`

#### doExecute

    protected <T> T doExecute(URI url,
                  HttpMethod method,
                  RequestCallback requestCallback,
                  ResponseExtractor<T> responseExtractor)
                   throws RestClientException

Execute the given method on the provided URI. The `ClientHttpRequest` is processed using the `RequestCallback`; the response with the `ResponseExtractor`.

Parameters:
  `url` - the fully-expanded URL to connect to
  `method` - the HTTP method to execute (GET, POST, etc.)
  `requestCallback` - object that prepares the request (can be `null`)
  `responseExtractor` - object that extracts the return value from the response (can be `null`)
Returns:
  an arbitrary object, as returned by the `ResponseExtractor`
Throws:
  `RestClientException`