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

  Spring's 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 variants 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, Brian Clozel
  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`.
    `RestTemplate(List<HttpMessageConverter<?>> messageConverters)` Create a new instance of the `RestTemplate` using the given list of `HttpMessageConverter` to use

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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()` Return 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. Default `HttpMessageConverter`s are initialized.

    - #### 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`, `HttpComponentsClientHttpRequestFactory`

    - #### RestTemplate

          public RestTemplate(List<HttpMessageConverter<?>> messageConverters)

      Create a new instance of the `RestTemplate` using the given list of `HttpMessageConverter` to use
      Parameters:
        `messageConverters` - the list of `HttpMessageConverter` to use
      Since:
        3.2.7

  - ### 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()

      Return the message body converters.

    - #### setErrorHandler

          public void setErrorHandler(ResponseErrorHandler errorHandler)

      Set the error handler.

      By default, RestTemplate uses a `DefaultResponseErrorHandler`.

    - #### getErrorHandler

          public ResponseErrorHandler getErrorHandler()

      Return the error handler.

    - #### 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`