springboot之RestTemplateUtils

回到首页☞

http请求是java web编程的核心功能，目前主流的方式三类java原生的，HttpClient和Spring的restTemplate。
对于一些老旧的jalor的系统会发现，换一拨人就会引入一个工具类，三种都用到了。
目前主流的java web框架就是spring全家桶，企业的二次封装后底层还是spring core，所以玩转restTemplate即可。

1、概述

spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。

在Spring应用程序中访问第三方REST服务与使用Spring RestTemplate类有关。RestTemplate类的设计原则与许多其他Spring *模板类(例如JdbcTemplate、JmsTemplate)相同，为执行复杂任务提供了一种具有默认行为的简化方法。

RestTemplate默认依赖JDK提供http连接的能力（HttpURLConnection），如果有需要的话也可以通过setRequestFactory方法替换为例如 Apache HttpComponents、Netty或OkHttp等其它HTTP library。

考虑到RestTemplate类是为调用REST服务而设计的，因此它的主要方法与REST的基础紧密相连就不足为奇了，后者是HTTP协议的方法:HEAD、GET、POST、PUT、DELETE和OPTIONS。例如，RestTemplate类具有headForHeaders()、getForObject()、postForObject()、put()和delete()等方法。

2、修改下pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wht.springboot.demo</groupId>
    <artifactId>com.wht.springboot.demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>mySpringbootDemo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8
        </project.reporting.outputEncoding>
        <mybatis-spring-boot.version>1.2.0</mybatis-spring-boot.version>
        <mysql-connector.version>5.1.39</mysql-connector.version>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector.version}</version>
        </dependency>

        <!--线程池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 热部署 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
            <version>1.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3、增加RestTemplateUtils

RestTemplate 在springboot中可以启动时增加bean，也可以采用RestTemplateConfig，这里暂时使用
RestTemplateUtils，因为这样传统的springmvc也可以使用。

package com.wht.springboot.demo.util;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

/**
 * RestTemplate 远程调用工具类
 *
 * @author JDIT
 * @createDate 2020-05-05
 *
 */
public class RestTemplateUtils {

  private static final RestTemplate restTemplate = new RestTemplate();

  // ----------------------------------GET-------------------------------------------------------

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

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

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

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

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

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

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

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

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

  /**
   * 带请求头的POST请求调用方式
   *
   * @param url 请求URL
   * @param headers 请求头参数
   * @param requestBody 请求参数体
   * @param responseType 返回对象类型
   * @param uriVariables URL中的变量，按顺序依次对应
   * @return ResponseEntity 响应对象封装类
   */
  public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
    return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
  }

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

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

  /**
   * PUT请求调用方式
   *
   * @param url 请求URL
   * @param requestBody 请求参数体
   * @param responseType 返回对象类型
   * @param uriVariables URL中的变量，按顺序依次对应
   * @return ResponseEntity 响应对象封装类
   */
  public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
    return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
  }

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

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

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

  /**
   * DELETE请求调用方式
   *
   * @param url 请求URL
   * @param requestBody 请求参数体
   * @param responseType 返回对象类型
   * @param uriVariables URL中的变量，按顺序依次对应
   * @return ResponseEntity 响应对象封装类
   */
  public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
    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 static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
    return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
  }

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

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

  /**
   * 获取RestTemplate实例对象，可自由调用其方法
   *
   * @return RestTemplate实例对象
   */
  public static RestTemplate getRestTemplate() {
    return restTemplate;
  }

}

4、增加test类-RestTest

import com.alibaba.fastjson.JSONObject;
import com.wht.springboot.demo.util.RestTemplateUtils;
import org.apache.commons.io.FileUtils;
import org.junit.Test;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.util.UriComponentsBuilder;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author JDIT
 */
public class RestTest {
  /**
   *
   * get path路径参数
   * 头在真实项目是必须的基本都要涉及SDK安全认证
   */
  @Test
  public void test() {
    String url = "http://localhost:9090/test/sayHello/{id}/{name}";
    Map<String, String> headers = new HashMap<>();
    headers.put("token", "12333");
    ResponseEntity<String> entity = RestTemplateUtils.get(url, headers,String.class, 123,"Jack");
    System.out.println(entity.getStatusCode());
    System.out.println(entity.getBody());
  }
｝

5、进行调试

• 先启动springboot工程
• 运行test

6、Get请求之路径参数

6.1、增加测试接口

  @RequestMapping(value = "sayHello/{id}/{name}",method=RequestMethod.GET)
  public String sayHello(@PathVariable("id") Integer id,@PathVariable("name") String name) {
    return String.format("Hello World %s,your id is %d",name,id );
  }

6.2、增加Test

  /**
   *
   * get path路径参数
   * 头在真实项目是必须的基本都要涉及SDK安全认证
   */
  @Test
  public void test() {
    String url = "http://localhost:9090/test/sayHello/{id}/{name}";
    Map<String, String> headers = new HashMap<>();
    headers.put("token", "12333");
    ResponseEntity<String> entity = RestTemplateUtils.get(url, headers,String.class, 123,"Jack");
    System.out.println(entity.getStatusCode());
    System.out.println(entity.getBody());
  }

7、Get请求之Query传参

7.1、增加测试接口

  @RequestMapping(value ="sayHelloRequestParam",method= RequestMethod.GET)
  public String sayHelloRequestParam(@RequestParam("name") String name) {
    return String.format("Hello World %s",name );
  }

7.2、增加Test

  /**
   * 测试带请求头参数Headers的GET请求，POST类似
   */
  @Test
  public void testHeaders() {
    String url = "http://localhost:9090/test/sayHelloRequestParam";
    UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(url)
        .queryParam("name", null).queryParam("id",123);
    System.out.println(builder.toUriString());
    Map<String, String> headers = new HashMap<>();
    headers.put("token", "12333");
    ResponseEntity<String> entity = RestTemplateUtils.get(builder.toUriString(), headers, String.class);
    System.out.println(entity.getStatusCode());
    System.out.println(entity.getBody());
  }

回到首页☞