/** * Returns a request callback implementation that prepares the request {@code Accept} * headers based on the given response type and configured {@linkplain * #getMessageConverters() message converters}. */ protected <T> AsyncRequestCallback acceptHeaderRequestCallback(Class<T> responseType) { return new AsyncRequestCallbackAdapter(this.syncTemplate.acceptHeaderRequestCallback(responseType)); }
/** * Set the error handler. * <p>By default, AsyncRestTemplate uses a * {@link org.springframework.web.client.DefaultResponseErrorHandler}. */ public void setErrorHandler(ResponseErrorHandler errorHandler) { this.syncTemplate.setErrorHandler(errorHandler); }
/** * Create a new instance of the {@link RestTemplate} based on the given {@link ClientHttpRequestFactory}. * @param requestFactory the HTTP request factory to use * @see org.springframework.http.client.SimpleClientHttpRequestFactory * @see org.springframework.http.client.HttpComponentsClientHttpRequestFactory */ public RestTemplate(ClientHttpRequestFactory requestFactory) { this(); setRequestFactory(requestFactory); }
/** * Construct a new instance of the {@link RestGatewaySupport}, with default parameters. */ public RestGatewaySupport() { this.restTemplate = new RestTemplate(); }
/** * Set the message body converters to use. * <p>These converters are used to convert from and to HTTP requests and responses. */ public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { this.syncTemplate.setMessageConverters(messageConverters); }
@Override public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws RestClientException { RequestCallback requestCallback = acceptHeaderRequestCallback(responseType); ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType); return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor)); }
@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Object... uriVariables) throws RestClientException { ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor(); return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables); }
@Override public <T> ListenableFuture<ResponseEntity<T>> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException { AsyncRequestCallback requestCallback = acceptHeaderRequestCallback(responseType); ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType); return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables); }
@Override public ListenableFuture<Set<HttpMethod>> optionsForAllow(String url, Object... uriVars) throws RestClientException { ResponseExtractor<HttpHeaders> extractor = headersExtractor(); ListenableFuture<HttpHeaders> future = execute(url, HttpMethod.OPTIONS, null, extractor, uriVars); return adaptToAllowHeader(future); }
/** * This property has the same purpose as the corresponding property on the * {@code RestTemplate}. For more details see * {@link RestTemplate#setUriTemplateHandler}. * @param handler the URI template handler to use */ public void setUriTemplateHandler(UriTemplateHandler handler) { this.syncTemplate.setUriTemplateHandler(handler); }
/** * Return the error handler. */ public ResponseErrorHandler getErrorHandler() { return this.syncTemplate.getErrorHandler(); }
/** * Return the configured URI template handler. */ public UriTemplateHandler getUriTemplateHandler() { return this.syncTemplate.getUriTemplateHandler(); }
/** * Return a {@code ResponseExtractor} that prepares a {@link ResponseEntity}. */ public <T> ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType) { return new ResponseEntityResponseExtractor<>(responseType); }
/** * Return a {@code RequestCallback} that sets the request {@code Accept} * header based on the given response type, cross-checked against the * configured message converters. */ public <T> RequestCallback acceptHeaderRequestCallback(Class<T> responseType) { return new AcceptHeaderRequestCallback(responseType); }
/** * Returns a response extractor for {@link ResponseEntity}. */ protected <T> ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType) { return this.syncTemplate.responseEntityExtractor(responseType); }
/** * Returns a response extractor for {@link HttpHeaders}. */ protected ResponseExtractor<HttpHeaders> headersExtractor() { return this.syncTemplate.headersExtractor(); }
@Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables) throws RestClientException { RequestCallback requestCallback = acceptHeaderRequestCallback(responseType); ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType); return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables)); }
@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Map<String, ?> uriVariables) throws RestClientException { ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor(); return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables); }
@Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException { RequestCallback requestCallback = acceptHeaderRequestCallback(responseType); ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType); return nonNull(execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables)); }
@Override public ListenableFuture<HttpHeaders> headForHeaders(URI url) throws RestClientException { ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor(); return execute(url, HttpMethod.HEAD, null, headersExtractor); }