SpringBoot系列之RestTemplate使用示例

转x33g5p2x  于2022-05-05 转载在 Spring  
字(28.7k)|赞(0)|评价(0)|浏览(487)

博主之前经常对接一些接口，所以发现写一些http请求比较麻烦，学习springboot的过程知道可以用RestTemplate来做http请求，RestTemplate是Spring Framework框架封装的基于模板方法设计模式的一个工具类，带有同步模板方法 API 的原始 Spring REST客户端类，下面博主分析一些对接过程的一些经验，RestTemplate基本使用可以参考官网文档：https://docs.spring.io/spring-framework/docs/5.1.6.RELEASE/spring-framework-reference/integration.html#rest-client-access

下面分析一些例子，先要进行环境准备：

  • 开发环境

  • JDK 1.8

  • SpringBoot2.2.1

  • Maven 3.2+

  • 开发工具

  • IntelliJ IDEA

  • smartGit

  • Navicat15

在IDEA里集成阿里的https://start.aliyun.com，创建一个Spring Initializr项目：

选择jdk版本，和maven打包方式

选择需要的dependencies

项目建好之后，可以对RestTemplate进行一些自定义的设置，比如可以拓展一下ClientHttpRequestInterceptor，做一些自己的拦截，打印一些日志

  1. package com.example.resttemplate.configuration;
  3. import cn.hutool.core.convert.Convert;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.http.HttpRequest;
  6. import org.springframework.http.client.ClientHttpRequestExecution;
  7. import org.springframework.http.client.ClientHttpRequestInterceptor;
  8. import org.springframework.http.client.ClientHttpResponse;
  10. import java.io.IOException;
  12. @Slf4j
  13. public class CustomClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
  15.     @Override
  16.     public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
  17.         trackRequest(httpRequest , bytes);
  18.         ClientHttpResponse httpResponse = clientHttpRequestExecution.execute(httpRequest , bytes);
  19.         trackResponse(httpResponse);
  20.         return httpResponse;
  21.     }
  23.     private void trackRequest(HttpRequest httpRequest, byte[] bytes) {
  24.         log.info("=======================request start=================================================");
  25.         log.info("Headers        : {}", httpRequest.getHeaders());
  26.         log.info("Request URI    : {}", httpRequest.getURI());
  27.         log.info("Request Method : {}", httpRequest.getMethod());
  28.         log.info("Request Body   : {}" , Convert.toStr(bytes));
  29.         log.info("=======================request end=================================================");
  30.     }
  32.     private void trackResponse(ClientHttpResponse httpResponse) throws IOException {
  33.         log.info("=======================response start=================================================");
  34.         log.info("Status code  : {}", httpResponse.getStatusCode());
  35.         log.info("Status text  : {}", httpResponse.getStatusText());
  36.         log.info("Headers      : {}", httpResponse.getHeaders());
  37.         log.info("=======================response end=================================================");
  39.     }
  41. }

自定义RestTemplateCustomizer类：

  1. package com.example.resttemplate.configuration;
  3. import org.springframework.boot.web.client.RestTemplateCustomizer;
  4. import org.springframework.web.client.RestTemplate;
  6. public class CustomRestTemplateCustomizer implements RestTemplateCustomizer {
  8.     @Override
  9.     public void customize(RestTemplate restTemplate) {
  10.         restTemplate.getInterceptors().add(new CustomClientHttpRequestInterceptor());
  11.     }
  12. }

写一个RestTemplate的配置类，注意需要加上RestTemplate的@Bean，我们在项目里才能使用@Autowired RestTemplate restTemplate;直接调用，@DependsOn是一个Spring框架底层的注解，会禁用RestTemplate默认的RestTemplateBuilder类，可以不加上

  1. package com.example.resttemplate.configuration;
  3. import org.springframework.boot.web.client.RestTemplateBuilder;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.context.annotation.DependsOn;
  7. import org.springframework.http.client.ClientHttpRequestFactory;
  8. import org.springframework.http.client.SimpleClientHttpRequestFactory;
  9. import org.springframework.web.client.RestTemplate;
  11. @Configuration
  12. public class RestTemplateConfiguration {
  14.     @Bean
  15.     public CustomRestTemplateCustomizer customRestTemplateCustomizer() {
  16.         return new CustomRestTemplateCustomizer();
  17.     }
  19.     @Bean
  20.     @DependsOn(value = {"customRestTemplateCustomizer"})
  21.     public RestTemplateBuilder restTemplateBuilder() {
  22.         return new RestTemplateBuilder(customRestTemplateCustomizer());
  23.     }
  25.     @Bean
  26.     public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
  27.         SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
  28.         //单位为ms
  29.         factory.setReadTimeout(5000);
  30.         //单位为ms
  31.         factory.setConnectTimeout(5000);
  32.         return factory;
  33.     }
  35.     @Bean
  36.     public RestTemplate restTemplate(RestTemplateBuilder builder ,ClientHttpRequestFactory factory ) {
  37.         RestTemplate restTemplate = builder.build();
  38.         restTemplate.setRequestFactory(factory);
  39.         return restTemplate;
  40.     }
  42. }

下面给出一个简单的例子，先写一个用户dto类：

  1. package com.example.resttemplate.model;
  3. import lombok.Data;
  5. @Data
  6. public class UserDto {
  8.     private Integer id;
  9.     private String login;
  10.     private String name;
  11.     private String company;
  12.     private String location;
  13.     private String email;
  15. }

通过restTemplate直接请求GitHub的用户api接口，写法是不是比自己写http的工具类，简洁很多了？

  1. package com.example.resttemplate.controller;
  3. import com.example.resttemplate.model.UserDto;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.PathVariable;
  7. import org.springframework.web.bind.annotation.RestController;
  8. import org.springframework.web.client.RestTemplate;
  10. @RestController
  11. public class SampleController {
  13.     @Autowired
  14.     RestTemplate restTemplate;
  16.     @GetMapping(value = "/users/{login}")
  17.     public UserDto getUser(@PathVariable("login")String login) {
  18.         String url = new StringBuilder()
  19.                 .append("https://api.github.com/users/")
  20.                 .append(login)
  21.                 .toString();
  22.         UserDto userDto = restTemplate.getForObject(url , UserDto.class , "");
  23.         return userDto;
  24.     }
  25. }

在Linux里调用接口curl http://127.0.0.1:8080/users/mojombo

getForEntity的例子，返回ResponseEntity

  1. MultiValueMap<String, Object> uriVariables = new LinkedMultiValueMap<String, Object>();
  2. ResponseEntity<String> responseEntity = restTemplate.getForEntity(apprWritUrl, String.class, uriVariables);
  3. logger.info("statusCode:{},responBody:{}", responseEntity.getStatusCode().value(), responseEntity.getBody());
  4. if (responseEntity.getStatusCode().value() == 200) {
  5.     logger.info("调用成功!");
  6.     // 业务处理
  7. }

postForEntity的例子

  1. HttpHeaders headers = new HttpHeaders();
  2. MultiValueMap<String,Object> params = new LinkedMultiValueMap<String, Object>(16) ;
  3. params.set("attachId",attachSeq);
  4. params.set("seq",seq);
  5. HttpEntity<MultiValueMap<String,Object>> requestEntity = new HttpEntity<MultiValueMap<String,Object>>(params, headers);
  6. ResponseEntity<String> entity = restTemplate.postForEntity("", requestEntity, String.class);

也可以使用restTemplate.exchange的方法，这个方法需要指定请求方式，比如HttpMethod.GET

  1. final String reqUrl = "url";
  2. HttpEntity<String> httpEntity = this.getHttpEntity();
  3. ResponseEntity<String> responseEntity = restTemplate.exchange(reqUrl,   HttpMethod.GET , httpEntity, String.class);
  4. logger.info("statusCode:{},responseBody:{}", responseEntity.getStatusCode().value(), responseEntity.getBody());

上传文件的例子，需要使用FileSystemResource封装一下

  1. RestTemplate restTemplate = new RestTemplate();
  2. FileSystemResource resource = new FileSystemResource(new File("D:\\test.txt"));
  3. MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
  4. param.add("file", resource);
  5. param.add("fileName", "test.txt");
  6. Object object = restTemplate.postForObject("http://127.0.0.1:8101/api/attachment/upload", param, Object.class);

对接有时候需要在请求头加很多校验参数，现在比较流行的是在网关里校验，下面是封装的方法，可以参考

  1. /**
  2.   * 构建HttpEntity
  3.   * @Author nicky
  4.   * @Date 2020/10/21 11:36
  5.   * @Param []
  6.   * @return org.springframework.http.HttpEntity<java.lang.String>
  7.   */
  8.  protected HttpEntity<String> getHttpEntity() throws Exception {
  9.      final String passToken = "passToken";
  10.      long now = new Date().getTime();
  11.      String timestamp = Long.toString((long) Math.floor(now / 1000));
  12.      String nonce = Long.toHexString(now) + "-" + Long.toHexString((long) Math.floor(Math.random() * 0xFFFFFF));
  13.      String signature= Signature.toSHA256(timestamp + passToken + nonce + timestamp);
  15.      HttpHeaders headers = new HttpHeaders();
  16.      headers.add("appid", "appid");
  17.      headers.add("serviceId","serviceId");
  18.      headers.add("signature", signature);
  19.      headers.add("timestamp", timestamp);
  20.      headers.add("nonce", nonce);
  21.      headers.add("Content-Type", "application/json");
  22.      headers.add("Cache-Control", "no-cache");
  24.      HttpEntity<String> httpEntity = new HttpEntity<String>(null, headers);
  25.      return httpEntity;
  26.  }

有时候对接，需要在postman里，很多参数都是动态的，我们可以写postman得一些脚本来测试

脚本参考，对接这个时间戳timestamp有时需要注意一些，要确定是毫秒的还是秒的的，参考博客：java时间戳 10位和13位分别是怎么来的？

  1. var timestamp = (Date.now()/1000).toFixed()
  2. var token=''
  3. var nonce= Math.floor(Math.random() * 10000000000)
  4. var appid=''
  6. var signature = CryptoJS.SHA256(timestamp + token + nonce + timestamp).toString(CryptoJS.enc.Hex).toUpperCase()
  7. pm.globals.set("variable_key", "variable_value");
  8. postman.setGlobalVariable("signature", signature);
  9. postman.setGlobalVariable("timestamp", timestamp);
  10. postman.setGlobalVariable("nonce", nonce);
  11. postman.setGlobalVariable("appid", appid);

博主对接过一些接口，需要一些签名加密的，下面给出一些工具类，参考，提高联调速度

  1. import java.security.MessageDigest;
  3. /**
  4.  *	<pre>
  5.  *	    sha256签名算法 
  6.  *	</pre>
  7.  */
  8. public class Signature {
  9. 	public static String toSHA256(String str) throws Exception {
  10. 		MessageDigest messageDigest;
  11. 		String encodeStr = "";
  12. 		try {
  13. 			messageDigest = MessageDigest.getInstance("SHA-256");
  14. 			messageDigest.update(str.getBytes("UTF-8"));
  15. 			encodeStr = byte2Hex(messageDigest.digest());
  16. 		} catch (Exception e) {
  17. 			throw e;
  18. 		}
  19. 		return encodeStr;
  20. 	}
  22. 	// byte转换成16进制
  23. 	protected static String byte2Hex(byte[] bytes) {
  24. 		StringBuffer stringBuffer = new StringBuffer();
  25. 		String temp = null;
  26. 		for (int i = 0; i < bytes.length; i++) {
  27. 			temp = Integer.toHexString(bytes[i] & 0xFF);
  28. 			if (temp.length() == 1) {
  29. 				stringBuffer.append("0");
  30. 			}
  31. 			stringBuffer.append(temp);
  32. 		}
  33. 		return stringBuffer.toString();
  34. 	}
  35. }

sha1加密，这个是对接企业微信时候用到

  1. /**
  2.  * sha1加密 <br>
  3.  * @Author nicky
  4.  * @Date 2021/04/26 10:22
  5.  * @Param [str]
  6.  * @return java.lang.String
  7.  */
  8. public static String sha1Digest(String str) {
  9.     try {
  10.         // SHA1签名生成
  11.         MessageDigest md = MessageDigest.getInstance("SHA-1");
  12.         md.update(str.getBytes());
  13.         byte[] digest = md.digest();
  15.         StringBuffer hexstr = new StringBuffer();
  16.         String shaHex = "";
  17.         for (int i = 0; i < digest.length; i++) {
  18.             shaHex = Integer.toHexString(digest[i] & 0xFF);
  19.             if (shaHex.length() < 2) {
  20.                 hexstr.append(0);
  21.             }
  22.             hexstr.append(shaHex);
  23.         }
  24.         return hexstr.toString();
  25.     } catch (Exception e) {
  26.         e.printStackTrace();
  27.         return null;
  28.     }
  29. }
  31.  /**
  32.   * <h2>对所有待签名参数按照字段名的ASCII 码从小到大排序</h2>
  33.   * @Author nicky
  34.   * @Date 2021/04/25 20:22
  35.   * @Param [params]
  36.   * @return java.lang.String
  37.   */
  38.  public static String sortSignByASCII(SortedMap<String , String> parameters) {
  39.      // 以k1=v1&k2=v2...方式拼接参数
  40.      StringBuilder builder = new StringBuilder();
  41.      for (Map.Entry<String, String> s : parameters.entrySet()) {
  42.          String k = s.getKey();
  43.          String v = s.getValue();
  44.          // 过滤空值
  45.          if (StringUtils.isBlank(v)) {
  46.              continue;
  47.          }
  48.          builder.append(k).append("=").append(v).append("&");
  49.      }
  50.      if (!parameters.isEmpty()) {
  51.          builder.deleteCharAt(builder.length() - 1);
  52.      }
  53.      return builder.toString();
  54.  }

网上复制的工具类，稍作修改

  1. package com.example.resttemplate.util;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.http.HttpEntity;
  7. import org.springframework.http.HttpHeaders;
  8. import org.springframework.http.HttpMethod;
  9. import org.springframework.http.ResponseEntity;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.web.client.RestClientException;
  12. import org.springframework.web.client.RestTemplate;
  14. import java.util.Map;
  16. @Slf4j
  17. @Component
  18. public class RestTemplateUtils {
  20.    @Autowired
  21.    @Qualifier("restTemplate")
  22.    private RestTemplate restTemplate;
  24.     /**
  25.      * GET请求调用方式
  26.      *
  27.      * @param url 请求URL
  28.      * @param responseType 返回对象类型
  29.      * @return ResponseEntity 响应对象封装类
  30.      */
  31.     public <T> ResponseEntity<T> get(String url, Class<T> responseType) throws RestClientException{
  32.         return restTemplate.getForEntity(url, responseType);
  33.     }
  35.     /**
  36.      * GET请求调用方式
  37.      *
  38.      * @param url 请求URL
  39.      * @param responseType 返回对象类型
  40.      * @param uriVariables URL中的变量，按顺序依次对应
  41.      * @return ResponseEntity 响应对象封装类
  42.      */
  43.     public <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) throws RestClientException{
  44.         return restTemplate.getForEntity(url, responseType, uriVariables);
  45.     }
  47.     /**
  48.      * GET请求调用方式
  49.      *
  50.      * @param url 请求URL
  51.      * @param responseType 返回对象类型
  52.      * @param uriVariables URL中的变量，与Map中的key对应
  53.      * @return ResponseEntity 响应对象封装类
  54.      */
  55.     public <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException{
  56.         return restTemplate.getForEntity(url, responseType, uriVariables);
  57.     }
  59.     /**
  60.      * 带请求头的GET请求调用方式
  61.      *
  62.      * @param url 请求URL
  63.      * @param headers 请求头参数
  64.      * @param responseType 返回对象类型
  65.      * @param uriVariables URL中的变量，按顺序依次对应
  66.      * @return ResponseEntity 响应对象封装类
  67.      */
  68.     public <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables)  throws RestClientException{
  69.         HttpHeaders httpHeaders = new HttpHeaders();
  70.         httpHeaders.setAll(headers);
  71.         return get(url, httpHeaders, responseType, uriVariables);
  72.     }
  74.     /**
  75.      * 带请求头的GET请求调用方式
  76.      *
  77.      * @param url 请求URL
  78.      * @param headers 请求头参数
  79.      * @param responseType 返回对象类型
  80.      * @param uriVariables URL中的变量，按顺序依次对应
  81.      * @return ResponseEntity 响应对象封装类
  82.      */
  83.     public <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) throws RestClientException{
  84.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  85.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
  86.     }
  88.     /**
  89.      * 带请求头的GET请求调用方式
  90.      *
  91.      * @param url 请求URL
  92.      * @param headers 请求头参数
  93.      * @param responseType 返回对象类型
  94.      * @param uriVariables URL中的变量，与Map中的key对应
  95.      * @return ResponseEntity 响应对象封装类
  96.      */
  97.     public <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
  98.         HttpHeaders httpHeaders = new HttpHeaders();
  99.         httpHeaders.setAll(headers);
  100.         return get(url, httpHeaders, responseType, uriVariables);
  101.     }
  103.     /**
  104.      * 带请求头的GET请求调用方式
  105.      *
  106.      * @param url 请求URL
  107.      * @param headers 请求头参数
  108.      * @param responseType 返回对象类型
  109.      * @param uriVariables URL中的变量，与Map中的key对应
  110.      * @return ResponseEntity 响应对象封装类
  111.      */
  112.     public <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
  113.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  114.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
  115.     }
  117.     /**
  118.      * POST请求调用方式
  119.      *
  120.      * @param url 请求URL
  121.      * @param responseType 返回对象类型
  122.      * @return
  123.      */
  124.     public <T> ResponseEntity<T> post(String url, Class<T> responseType) throws RestClientException{
  125.         return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
  126.     }
  128.     /**
  129.      * POST请求调用方式
  130.      *
  131.      * @param url 请求URL
  132.      * @param requestBody 请求参数体
  133.      * @param responseType 返回对象类型
  134.      * @return ResponseEntity 响应对象封装类
  135.      */
  136.     public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) throws RestClientException {
  137.         return restTemplate.postForEntity(url, requestBody, responseType);
  138.     }
  140.     /**
  141.      * POST请求调用方式
  142.      *
  143.      * @param url 请求URL
  144.      * @param requestBody 请求参数体
  145.      * @param responseType 返回对象类型
  146.      * @param uriVariables URL中的变量，按顺序依次对应
  147.      * @return ResponseEntity 响应对象封装类
  148.      */
  149.     public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) throws RestClientException{
  150.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
  151.     }
  153.     /**
  154.      * POST请求调用方式
  155.      *
  156.      * @param url 请求URL
  157.      * @param requestBody 请求参数体
  158.      * @param responseType 返回对象类型
  159.      * @param uriVariables URL中的变量，与Map中的key对应
  160.      * @return ResponseEntity 响应对象封装类
  161.      */
  162.     public <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
  163.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
  164.     }
  166.     /**
  167.      * 带请求头的POST请求调用方式
  168.      *
  169.      * @param url 请求URL
  170.      * @param headers 请求头参数
  171.      * @param requestBody 请求参数体
  172.      * @param responseType 返回对象类型
  173.      * @param uriVariables URL中的变量，按顺序依次对应
  174.      * @return ResponseEntity 响应对象封装类
  175.      */
  176.     public <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
  177.                                       Object... uriVariables) throws RestClientException{
  178.         HttpHeaders httpHeaders = new HttpHeaders();
  179.         httpHeaders.setAll(headers);
  180.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
  181.     }
  183.     /**
  184.      * 带请求头的POST请求调用方式
  185.      *
  186.      * @param url 请求URL
  187.      * @param headers 请求头参数
  188.      * @param requestBody 请求参数体
  189.      * @param responseType 返回对象类型
  190.      * @param uriVariables URL中的变量，按顺序依次对应
  191.      * @return ResponseEntity 响应对象封装类
  192.      */
  193.     public <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
  194.                                       Object... uriVariables) throws RestClientException{
  195.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  196.         return post(url, requestEntity, responseType, uriVariables);
  197.     }
  199.     /**
  200.      * 带请求头的POST请求调用方式
  201.      *
  202.      * @param url 请求URL
  203.      * @param headers 请求头参数
  204.      * @param requestBody 请求参数体
  205.      * @param responseType 返回对象类型
  206.      * @param uriVariables URL中的变量，与Map中的key对应
  207.      * @return ResponseEntity 响应对象封装类
  208.      */
  209.     public <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
  210.                                       Map<String, ?> uriVariables) throws RestClientException{
  211.         HttpHeaders httpHeaders = new HttpHeaders();
  212.         httpHeaders.setAll(headers);
  213.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
  214.     }
  216.     /**
  217.      * 带请求头的POST请求调用方式
  218.      *
  219.      * @param url 请求URL
  220.      * @param headers 请求头参数
  221.      * @param requestBody 请求参数体
  222.      * @param responseType 返回对象类型
  223.      * @param uriVariables URL中的变量，与Map中的key对应
  224.      * @return ResponseEntity 响应对象封装类
  225.      */
  226.     public <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
  227.                                              Map<String, ?> uriVariables) throws RestClientException{
  228.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  229.         return post(url, requestEntity, responseType, uriVariables);
  230.     }
  232.     /**
  233.      * 自定义请求头和请求体的POST请求调用方式
  234.      *
  235.      * @param url 请求URL
  236.      * @param requestEntity 请求头和请求体封装对象
  237.      * @param responseType 返回对象类型
  238.      * @param uriVariables URL中的变量，按顺序依次对应
  239.      * @return ResponseEntity 响应对象封装类
  240.      */
  241.     public <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType,
  242.                                              Object... uriVariables) throws RestClientException{
  243.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
  244.     }
  246.     /**
  247.      * 自定义请求头和请求体的POST请求调用方式
  248.      *
  249.      * @param url 请求URL
  250.      * @param requestEntity 请求头和请求体封装对象
  251.      * @param responseType 返回对象类型
  252.      * @param uriVariables URL中的变量，与Map中的key对应
  253.      * @return ResponseEntity 响应对象封装类
  254.      */
  255.     public <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType
  256.             , Map<String, ?> uriVariables) throws RestClientException {
  257.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
  258.     }
  260.     /**
  261.      * PUT请求调用方式
  262.      *
  263.      * @param url 请求URL
  264.      * @param responseType 返回对象类型
  265.      * @param uriVariables URL中的变量，按顺序依次对应
  266.      * @return ResponseEntity 响应对象封装类
  267.      */
  268.     public <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) throws RestClientException{
  269.         return put(url, HttpEntity.EMPTY, responseType, uriVariables);
  270.     }
  272.     /**
  273.      * PUT请求调用方式
  274.      *
  275.      * @param url 请求URL
  276.      * @param requestBody 请求参数体
  277.      * @param responseType 返回对象类型
  278.      * @param uriVariables URL中的变量，按顺序依次对应
  279.      * @return ResponseEntity 响应对象封装类
  280.      */
  281.     public <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) throws RestClientException{
  282.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  283.         return put(url, requestEntity, responseType, uriVariables);
  284.     }
  286.     /**
  287.      * PUT请求调用方式
  288.      *
  289.      * @param url 请求URL
  290.      * @param requestBody 请求参数体
  291.      * @param responseType 返回对象类型
  292.      * @param uriVariables URL中的变量，与Map中的key对应
  293.      * @return ResponseEntity 响应对象封装类
  294.      */
  295.     public <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
  296.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  297.         return put(url, requestEntity, responseType, uriVariables);
  298.     }
  300.     /**
  301.      * 带请求头的PUT请求调用方式
  302.      *
  303.      * @param url 请求URL
  304.      * @param headers 请求头参数
  305.      * @param requestBody 请求参数体
  306.      * @param responseType 返回对象类型
  307.      * @param uriVariables URL中的变量，按顺序依次对应
  308.      * @return ResponseEntity 响应对象封装类
  309.      */
  310.     public <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
  311.                                      Object... uriVariables) throws RestClientException{
  312.         HttpHeaders httpHeaders = new HttpHeaders();
  313.         httpHeaders.setAll(headers);
  314.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
  315.     }
  317.     /**
  318.      * 带请求头的PUT请求调用方式
  319.      *
  320.      * @param url 请求URL
  321.      * @param headers 请求头参数
  322.      * @param requestBody 请求参数体
  323.      * @param responseType 返回对象类型
  324.      * @param uriVariables URL中的变量，按顺序依次对应
  325.      * @return ResponseEntity 响应对象封装类
  326.      */
  327.     public <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
  328.                                      Object... uriVariables) throws RestClientException{
  329.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  330.         return put(url, requestEntity, responseType, uriVariables);
  331.     }
  333.     /**
  334.      * 带请求头的PUT请求调用方式
  335.      *
  336.      * @param url 请求URL
  337.      * @param headers 请求头参数
  338.      * @param requestBody 请求参数体
  339.      * @param responseType 返回对象类型
  340.      * @param uriVariables URL中的变量，与Map中的key对应
  341.      * @return ResponseEntity 响应对象封装类
  342.      */
  343.     public <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType,
  344.                                      Map<String, ?> uriVariables) throws RestClientException{
  345.         HttpHeaders httpHeaders = new HttpHeaders();
  346.         httpHeaders.setAll(headers);
  347.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
  348.     }
  350.     /**
  351.      * 带请求头的PUT请求调用方式
  352.      *
  353.      * @param url 请求URL
  354.      * @param headers 请求头参数
  355.      * @param requestBody 请求参数体
  356.      * @param responseType 返回对象类型
  357.      * @param uriVariables URL中的变量，与Map中的key对应
  358.      * @return ResponseEntity 响应对象封装类
  359.      */
  360.     public <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType,
  361.                                      Map<String, ?> uriVariables) throws RestClientException{
  362.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  363.         return put(url, requestEntity, responseType, uriVariables);
  364.     }
  366.     /**
  367.      * 自定义请求头和请求体的PUT请求调用方式
  368.      *
  369.      * @param url 请求URL
  370.      * @param requestEntity 请求头和请求体封装对象
  371.      * @param responseType 返回对象类型
  372.      * @param uriVariables URL中的变量，按顺序依次对应
  373.      * @return ResponseEntity 响应对象封装类
  374.      */
  375.     public <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType,
  376.                                      Object... uriVariables) throws RestClientException{
  377.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
  378.     }
  380.     /**
  381.      * 自定义请求头和请求体的PUT请求调用方式
  382.      *
  383.      * @param url 请求URL
  384.      * @param requestEntity 请求头和请求体封装对象
  385.      * @param responseType 返回对象类型
  386.      * @param uriVariables URL中的变量，与Map中的key对应
  387.      * @return ResponseEntity 响应对象封装类
  388.      */
  389.     public <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType,
  390.                                      Map<String, ?> uriVariables) throws RestClientException {
  391.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
  392.     }
  394.     /**
  395.      * DELETE请求调用方式
  396.      *
  397.      * @param url 请求URL
  398.      * @param responseType 返回对象类型
  399.      * @param uriVariables URL中的变量，按顺序依次对应
  400.      * @return ResponseEntity 响应对象封装类
  401.      */
  402.     public <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) throws RestClientException{
  403.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
  404.     }
  406.     /**
  407.      * DELETE请求调用方式
  408.      *
  409.      * @param url 请求URL
  410.      * @param responseType 返回对象类型
  411.      * @param uriVariables URL中的变量，与Map中的key对应
  412.      * @return ResponseEntity 响应对象封装类
  413.      */
  414.     public <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException{
  415.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
  416.     }
  418.     /**
  419.      * DELETE请求调用方式
  420.      *
  421.      * @param url 请求URL
  422.      * @param requestBody 请求参数体
  423.      * @param responseType 返回对象类型
  424.      * @param uriVariables URL中的变量，按顺序依次对应
  425.      * @return ResponseEntity 响应对象封装类
  426.      */
  427.     public <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType,
  428.                                         Object... uriVariables) throws RestClientException{
  429.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  430.         return delete(url, requestEntity, responseType, uriVariables);
  431.     }
  433.     /**
  434.      * DELETE请求调用方式
  435.      *
  436.      * @param url 请求URL
  437.      * @param requestBody 请求参数体
  438.      * @param responseType 返回对象类型
  439.      * @param uriVariables URL中的变量，与Map中的key对应
  440.      * @return ResponseEntity 响应对象封装类
  441.      */
  442.     public <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType
  443.             , Map<String, ?> uriVariables) throws RestClientException{
  444.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  445.         return delete(url, requestEntity, responseType, uriVariables);
  446.     }
  448.     /**
  449.      * 带请求头的DELETE请求调用方式
  450.      *
  451.      * @param url 请求URL
  452.      * @param headers 请求头参数
  453.      * @param responseType 返回对象类型
  454.      * @param uriVariables URL中的变量，按顺序依次对应
  455.      * @return ResponseEntity 响应对象封装类
  456.      */
  457.     public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType,
  458.                                                Object... uriVariables) throws RestClientException{
  459.         HttpHeaders httpHeaders = new HttpHeaders();
  460.         httpHeaders.setAll(headers);
  461.         return delete(url, httpHeaders, responseType, uriVariables);
  462.     }
  464.     /**
  465.      * 带请求头的DELETE请求调用方式
  466.      *
  467.      * @param url 请求URL
  468.      * @param headers 请求头参数
  469.      * @param responseType 返回对象类型
  470.      * @param uriVariables URL中的变量，按顺序依次对应
  471.      * @return ResponseEntity 响应对象封装类
  472.      */
  473.     public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType
  474.             , Object... uriVariables) throws RestClientException {
  475.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
  476.         return delete(url, requestEntity, responseType, uriVariables);
  477.     }
  479.     /**
  480.      * 带请求头的DELETE请求调用方式
  481.      *
  482.      * @param url 请求URL
  483.      * @param headers 请求头参数
  484.      * @param responseType 返回对象类型
  485.      * @param uriVariables URL中的变量，与Map中的key对应
  486.      * @return ResponseEntity 响应对象封装类
  487.      */
  488.     public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType
  489.             , Map<String, ?> uriVariables) throws RestClientException{
  490.         HttpHeaders httpHeaders = new HttpHeaders();
  491.         httpHeaders.setAll(headers);
  492.         return delete(url, httpHeaders, responseType, uriVariables);
  493.     }
  495.     /**
  496.      * 带请求头的DELETE请求调用方式
  497.      *
  498.      * @param url 请求URL
  499.      * @param headers 请求头参数
  500.      * @param responseType 返回对象类型
  501.      * @param uriVariables URL中的变量，与Map中的key对应
  502.      * @return ResponseEntity 响应对象封装类
  503.      */
  504.     public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType
  505.             , Map<String, ?> uriVariables) throws RestClientException{
  506.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
  507.         return delete(url, requestEntity, responseType, uriVariables);
  508.     }
  510.     /**
  511.      * 带请求头的DELETE请求调用方式
  512.      *
  513.      * @param url 请求URL
  514.      * @param headers 请求头参数
  515.      * @param requestBody 请求参数体
  516.      * @param responseType 返回对象类型
  517.      * @param uriVariables URL中的变量，按顺序依次对应
  518.      * @return ResponseEntity 响应对象封装类
  519.      */
  520.     public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody,
  521.                                         Class<T> responseType, Object... uriVariables)throws RestClientException {
  522.         HttpHeaders httpHeaders = new HttpHeaders();
  523.         httpHeaders.setAll(headers);
  524.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
  525.     }
  527.     /**
  528.      * 带请求头的DELETE请求调用方式
  529.      *
  530.      * @param url 请求URL
  531.      * @param headers 请求头参数
  532.      * @param requestBody 请求参数体
  533.      * @param responseType 返回对象类型
  534.      * @param uriVariables URL中的变量，按顺序依次对应
  535.      * @return ResponseEntity 响应对象封装类
  536.      */
  537.     public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody,
  538.                                         Class<T> responseType, Object... uriVariables) throws RestClientException{
  539.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  540.         return delete(url, requestEntity, responseType, uriVariables);
  541.     }
  543.     /**
  544.      * 带请求头的DELETE请求调用方式
  545.      *
  546.      * @param url 请求URL
  547.      * @param headers 请求头参数
  548.      * @param requestBody 请求参数体
  549.      * @param responseType 返回对象类型
  550.      * @param uriVariables URL中的变量，与Map中的key对应
  551.      * @return ResponseEntity 响应对象封装类
  552.      */
  553.     public <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody,
  554.                                         Class<T> responseType, Map<String, ?> uriVariables)throws RestClientException {
  555.         HttpHeaders httpHeaders = new HttpHeaders();
  556.         httpHeaders.setAll(headers);
  557.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
  558.     }
  560.     /**
  561.      * 带请求头的DELETE请求调用方式
  562.      *
  563.      * @param url 请求URL
  564.      * @param headers 请求头参数
  565.      * @param requestBody 请求参数体
  566.      * @param responseType 返回对象类型
  567.      * @param uriVariables URL中的变量，与Map中的key对应
  568.      * @return ResponseEntity 响应对象封装类
  569.      */
  570.     public <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody,
  571.                                         Class<T> responseType, Map<String, ?> uriVariables)throws RestClientException {
  572.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  573.         return delete(url, requestEntity, responseType, uriVariables);
  574.     }
  576.     /**
  577.      * 自定义请求头和请求体的DELETE请求调用方式
  578.      *
  579.      * @param url 请求URL
  580.      * @param requestEntity 请求头和请求体封装对象
  581.      * @param responseType 返回对象类型
  582.      * @param uriVariables URL中的变量，按顺序依次对应
  583.      * @return ResponseEntity 响应对象封装类
  584.      */
  585.     public <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType,
  586.                                         Object... uriVariables)throws RestClientException {
  587.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
  588.     }
  590.     /**
  591.      * 自定义请求头和请求体的DELETE请求调用方式
  592.      *
  593.      * @param url 请求URL
  594.      * @param requestEntity 请求头和请求体封装对象
  595.      * @param responseType 返回对象类型
  596.      * @param uriVariables URL中的变量，与Map中的key对应
  597.      * @return ResponseEntity 响应对象封装类
  598.      */
  599.     public <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType,
  600.                                         Map<String, ?> uriVariables) throws RestClientException{
  601.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
  602.     }
  604.     /**
  605.      * 通用调用方式
  606.      *
  607.      * @param url 请求URL
  608.      * @param method 请求方法类型
  609.      * @param requestEntity 请求头和请求体封装对象
  610.      * @param responseType 返回对象类型
  611.      * @param uriVariables URL中的变量，按顺序依次对应
  612.      * @return ResponseEntity 响应对象封装类
  613.      */
  614.     public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
  615.                                           Class<T> responseType, Object... uriVariables)throws RestClientException {
  616.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
  617.     }
  619.     /**
  620.      * 通用调用方式
  621.      *
  622.      * @param url 请求URL
  623.      * @param method 请求方法类型
  624.      * @param requestEntity 请求头和请求体封装对象
  625.      * @param responseType 返回对象类型
  626.      * @param uriVariables URL中的变量，与Map中的key对应
  627.      * @return ResponseEntity 响应对象封装类
  628.      */
  629.     public  <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
  630.                                            Class<T> responseType, Map<String, ?> uriVariables)throws RestClientException {
  631.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
  632.     }
  636. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://smilenicky.blog.csdn.net/article/details/108831497

内容来源于网络，如有侵权，请联系作者删除！

Javaspring

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com