Spring Boot中RestTemplate开发实践(2)

什么是RestTemplate？

RestTemplate 是从 Spring3.0 开始支持的一个 HTTP 请求工具，它提供了常见的REST请求方案的模版，例如 GET 请求、POST 请求、PUT 请求、DELETE 请求以及一些通用的请求执行方法 exchange 以及 execute。

上一篇文章：Spring Boot中RestTemplate开发实践（1）

为了方便使用RestTemplate 类的方法，进行了封装，创建RestTemplateUtils 工具类的代码如下所示：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

/**
* @desc http请求工具类
*/
@Component
public class RestTemplateUtils {

 @Autowired
 private RestTemplate restTemplate;

 // ----------------------------------GET-------------------------------------------------------
 /**
 * GET请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, Class<T> responseType) throws RestClientException {
 return restTemplate.getForEntity(url, responseType);
 }

 /**
 * GET请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 return restTemplate.getForEntity(url, responseType, uriVariables);
 }

 /**
 * GET请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables)
 throws RestClientException {
 return restTemplate.getForEntity(url, responseType, uriVariables);
 }

 /**
 * 带请求头的GET请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return get(url, httpHeaders, responseType, uriVariables);
 }

 /**
 * 带请求头的GET请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的GET请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return get(url, httpHeaders, responseType, uriVariables);
 }

 /**
 * 带请求头的GET请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
 }

 // ----------------------------------POST-------------------------------------------------------

 /**
 * POST请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @return
 */
 public <T> ResponseEntity<T> post(String url, Class<T> responseType) throws RestClientException {
 return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
 }

 /**
 * POST请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType)
 throws RestClientException {
 return restTemplate.postForEntity(url, requestBody, responseType);
 }

 /**
 * POST请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
 }

 /**
 * POST请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的POST请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody,
 Class<T> responseType, Object... uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return post(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的POST请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return post(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的POST请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody,
 Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return post(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的POST请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return post(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的POST请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的POST请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
 }

 // ----------------------------------PUT-------------------------------------------------------

 /**
 * PUT请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 return put(url, HttpEntity.EMPTY, responseType, uriVariables);
 }

 /**
 * PUT请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
 return put(url, requestEntity, responseType, uriVariables);
 }

 /**
 * PUT请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables)
 throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
 return put(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的PUT请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return put(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的PUT请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return put(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的PUT请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return put(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的PUT请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return put(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的PUT请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的PUT请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
 }

 // ----------------------------------DELETE-------------------------------------------------------

 /**
 * DELETE请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
 }

 /**
 * DELETE请求调用方式
 *
 * @param url 请求URL
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables)
 throws RestClientException {
 return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
 }

 /**
 * DELETE请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * DELETE请求调用方式
 *
 * @param url 请求URL
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return delete(url, httpHeaders, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return delete(url, httpHeaders, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody,
 Class<T> responseType, Object... uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return delete(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody,
 Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
 HttpHeaders httpHeaders = new HttpHeaders();
 httpHeaders.setAll(headers);
 return delete(url, httpHeaders, requestBody, responseType, uriVariables);
 }

 /**
 * 带请求头的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param headers 请求头参数
 * @param requestBody 请求参数体
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
 return delete(url, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Object... uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
 }

 /**
 * 自定义请求头和请求体的DELETE请求调用方式
 *
 * @param url 请求URL
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType,
 Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
 }

 // ----------------------------------通用方法-------------------------------------------------------

 /**
 * 通用调用方式
 *
 * @param url 请求URL
 * @param method 请求方法类型
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，按顺序依次对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
 Class<T> responseType, Object... uriVariables) throws RestClientException {
 return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
 }

 /**
 * 通用调用方式
 *
 * @param url 请求URL
 * @param method 请求方法类型
 * @param requestEntity 请求头和请求体封装对象
 * @param responseType 返回对象类型
 * @param uriVariables URL中的变量，与Map中的key对应
 * @return ResponseEntity 响应对象封装类
 */
 public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
 Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
 }
}