SpringBoot——RestTemplate使用指南

一、背景介绍

在微服务架构下都是以HTTP接口的形式暴露自身服务的，因此在调用远程服务时就必须使用HTTP客户端。我们可以使用JDK原生的URLConnection、Apache的Http Client、Netty的异步HTTP Client, Spring的RestTemplate。这里介绍的是RestTemplate。RestTemplate底层使用HttpClient和OkHttp，对其做了封装，使用起来更简单。

1、什么是RestTemplate？

RestTemplate是Spring提供的用于访问Rest服务的客户端， RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。

 

调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求， 可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。

 

ClientHttpRequestFactory接口主要提供了两种实现方式

• 1、一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）创建底层的Http请求连接。
• 2、一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。
• 3、第三种方式是使用OkHttp3ClientHttpRequestFactory方式，底层使用OkHttp访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

其实spring并没有真正的去实现底层的http请求（3次握手），而是集成了别的http请求，spring只是在原有的各种http请求进行了规范标准，让开发者更加简单易用，底层默认用的是jdk的http请求。

2、RestTemplate的优缺点：

• 优点：连接池、超时时间设置、支持异步、请求和响应的编解码
• 缺点：依赖别的spring版块、参数传递不灵活

RestTemplate默认是使用SimpleClientHttpRequestFactory，内部是调用jdk的HttpConnection，默认超时为-1

@Autowired RestTemplate simpleRestTemplate; @Autowired RestTemplate restTemplate;

二、配置RestTemplate——httpclient

1、引入依赖

<dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.13</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>

2、连接池配置

#最大连接数 http.maxTotal=100 #并发数 http.defaultMaxPerRoute=20 #创建连接的最长时间 http.connectTimeout=1000 #从连接池中获取到连接的最长时间 http.connectionRequestTimeout=500 #数据传输的最长时间 http.socketTimeout=10000 #提交请求前测试连接是否可用 http.staleConnectionCheckEnabled=true #可用空闲连接过期时间,重用空闲连接时会先检查是否空闲时间超过这个时间，如果超过，释放socket重新建立 http.validateAfterInactivity=3000000

3、初始化连接池

@Configuration public class RestTemplateConfig { @Value("${http.maxTotal}") private Integer maxTotal; @Value("${http.defaultMaxPerRoute}") private Integer defaultMaxPerRoute; @Value("${http.connectTimeout}") private Integer connectTimeout; @Value("${http.connectionRequestTimeout}") private Integer connectionRequestTimeout; @Value("${http.socketTimeout}") private Integer socketTimeout; @Value("${http.staleConnectionCheckEnabled}") private boolean staleConnectionCheckEnabled; @Value("${http.validateAfterInactivity}") private Integer validateAfterInactivity; @Bean public RestTemplate restTemplate() { return new RestTemplate(httpRequestFactory()); } @Bean public ClientHttpRequestFactory httpRequestFactory() { return new HttpComponentsClientHttpRequestFactory(httpClient()); } @Bean public HttpClient httpClient() { Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", SSLConnectionSocketFactory.getSocketFactory()) .build(); PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry); connectionManager.setMaxTotal(maxTotal); // 最大连接数 connectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute); //单个路由最大连接数 connectionManager.setValidateAfterInactivity(validateAfterInactivity); // 最大空间时间 RequestConfig requestConfig = RequestConfig.custom() .setSocketTimeout(socketTimeout) //服务器返回数据(response)的时间，超过抛出read timeout .setConnectTimeout(connectTimeout) //连接上服务器(握手成功)的时间，超出抛出connect timeout .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled) // 提交前检测是否可用 .setConnectionRequestTimeout(connectionRequestTimeout)//从连接池中获取连接的超时时间，超时间未拿到可用连接，会抛出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool .build(); //headers List<Header> headers = new ArrayList<>(); headers.add(new BasicHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.16 Safari/537.36")); headers.add(new BasicHeader("Accept-Encoding", "gzip,deflate")); headers.add(new BasicHeader("Accept-Language", "zh-CN")); headers.add(new BasicHeader("Connection", "Keep-Alive")); headers.add(new BasicHeader("Content-type", "application/json;charset=UTF-8")); return HttpClientBuilder.create() .setDefaultRequestConfig(requestConfig) .setConnectionManager(connectionManager) .setDefaultHeaders(headers) // 保持长连接配置，需要在头添加Keep-Alive .setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy()) //重试次数，默认是3次，没有开启 .setRetryHandler(new DefaultHttpRequestRetryHandler(2, true)) .build(); } }

首先解释以下@configuration，它的主要作用就是在spring容器启动的时候，初始化IOC,使用了这个注解，那么该类就会在spring启动的时候，把@Bean注解标识的类进行依赖注入。@Bean理解的话，就好比在配置文件中配置<bean id="xxx">.接下来就是在restTemplate的构造方法中添加httpRequest的工厂，使用连接池来优化http通信，默认使用长连接时间为30秒，再设置路由让http连接定向到指定的IP,然后设置并发数。再就是设置请求配置的超时时间，为了防止请求时间过长而引起资源的过渡浪费。如果在超过设置的timeout还没有数据返回，就直接断开连接。headers是添加默认的请求头，这里设置了传送的格式为json，语言为中-英等等属性。HttpClientBuilder.create设置请求头到HttpClient,然后在设置保持的时间，重试的次数，注入给httpClient进行封装。

 

在bean中的HttpMessageConverter，就是http信息转换器，它的主要作用就是转换和解析返回来的json数据，restTemplate默认使用jackson来作为底层的解析工具，而其它的比如Gson,fastjson等等第三方开源库放在headers这个list中，如果要使用，可以通过以下代码进行改变：

this.restTemplate.getMessageConverters().clear(); final List<HttpMessageConverter<?>> myHttpMessageConverter = new ArrayList<HttpMessageConverter<?>>(); //自己实现的messgeConverter HttpMessageConverter<Object> messageConverter = new MyHttpMessageConverter<Object>(); myHttpMessageConverter.add(messageConverter); this.restTemplate.setMessageConverters(myHttpMessageConverter);

三、配置RestTemplate——okhttp

1、引入依赖

<dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>4.9.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>

2、声明 RestTemplate

/** * @author: huangyibo * @Date: 2021/7/19 15:35 * @Description: */ @Configuration public class OkHttpConfig { /** * 基于OkHttp3配置RestTemplate * @return */ @Bean public RestTemplate restTemplate() { OkHttpClient httpClient = okHttpClient(); OkHttp3ClientHttpRequestFactory factory = new OkHttp3ClientHttpRequestFactory(httpClient); RestTemplate restTemplate = new RestTemplate(factory); // 可以添加消息转换 //restTemplate.setMessageConverters(...); // 可以增加拦截器 //restTemplate.setInterceptors(...); return restTemplate; } @Bean public OkHttpClient okHttpClient() { return new OkHttpClient.Builder() //.sslSocketFactory(sslSocketFactory(), x509TrustManager()) .retryOnConnectionFailure(false) .connectionPool(pool()) .connectTimeout(30, TimeUnit.SECONDS) .readTimeout(30, TimeUnit.SECONDS) .writeTimeout(30,TimeUnit.SECONDS) .build(); } @Bean public X509TrustManager x509TrustManager() { return new X509TrustManager() { @Override public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException { } @Override public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException { } @Override public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; } }; } @Bean public SSLSocketFactory sslSocketFactory() { try { //信任任何链接 SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom()); return sslContext.getSocketFactory(); } catch (NoSuchAlgorithmException | KeyManagementException e) { e.printStackTrace(); } return null; } /** * Create a new connection pool with tuning parameters appropriate for a single-user application. * The tuning parameters in this pool are subject to change in future OkHttp releases. Currently */ @Bean public ConnectionPool pool() { return new ConnectionPool(200, 5, TimeUnit.MINUTES); } }

okhttp：OkHttp是一个高效的HTTP客户端，允许所有同一个主机地址的请求共享同一个socket连接；连接池减少请求延时；透明的GZIP压缩减少响应数据的大小；缓存响应内容，避免一些完全重复的请求。

 

当网络出现问题的时候OkHttp依然坚守自己的职责，它会自动恢复一般的连接问题，如果你的服务有多个IP地址，当第一个IP请求失败时，OkHttp会交替尝试你配置的其他IP，OkHttp使用现代TLS技术(SNI, ALPN)初始化新的连接，当握手失败时会回退到TLS 1.0。

 

使用：它的请求/响应 API 使用构造器模式builders来设计，它支持阻塞式的同步请求和带回调的异步请求。

四、RestTemplate调用https接口

RestTemplate调用https接口需要改造RestTemplate

@Bean public RestTemplate getRestTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException { SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() { @Override public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException { return true; } }).build(); SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new String[]{"TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE); CloseableHttpClient httpClient = HttpClients.custom() .setSSLSocketFactory(csf) .build(); HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(); requestFactory.setHttpClient(httpClient); return new RestTemplate(requestFactory); }

五、对RestTemplate进行封装，用来执行Http请求。

/** * @author: huangyibo * @Date: 2021/7/19 14:09 * @Description: 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); } }

参考： https://zhuanlan.zhihu.com/p/142011874

https://www.cnblogs.com/wyq178/p/9058030.html

https://www.cnblogs.com/yuexiaoyun/articles/13034028.html

https://zhuanlan.zhihu.com/p/108765123

https://www.cnblogs.com/wzk-0000/p/10955406.html