restTemplate工具類

utils

package javax.utils;

import java.util.Map;

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;

/**
 * RestTemplate 遠程調用工具類
 * 
 * @author Logan
 * @createDate 2019-02-08
 *
 */
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;
    }

}

測試代碼：

package test;

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

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 com.alibaba.fastjson.JSONObject;

import utils.RestTemplateUtils;

/**
 * RestTemplate 功能測試類
 * 
 * @author Logan
 * @createDate 2019-02-08
 *
 */
public class RestTest {

    /**
     * 測試HTTPS請求訪問博客園
     */
    @Test
    public void test() {
        String url = "https://www.cnblogs.com/{id}/p/{pageName}.html";
        String id = "jonban";
        List<String> pages = new ArrayList<>();
        pages.add("rest");
        pages.add("jsoup");
        pages.add("sms");
        pages.add("rememberMe");
        pages.add("properties");
        pages.add("async");

        for (String pageName : pages) {
            ResponseEntity<String> entity = RestTemplateUtils.get(url, String.class, id, pageName);
            System.out.println(entity.getStatusCode());
            System.out.println(entity.getBody());
        }

    }

    /**
     * 測試帶請求頭參數Headers的GET請求，POST類似
     */
    @Test
    public void testHeaders() {
        String url = "http://127.0.0.1:8080/test/Logan?age=16";
        Map<String, String> headers = new HashMap<>();
        headers.put("appId", "Basic MyAppId");
        ResponseEntity<String> entity = RestTemplateUtils.get(url, headers, String.class);
        System.out.println(entity.getStatusCode());
        System.out.println(entity.getBody());
    }

    /**
     * 測試普通表單參數的POST請求
     */
    @Test
    public void sayHello() {
        String url = "http://127.0.0.1:8080/test/sayHello";
        MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>();
        requestBody.add("name", "Logan");
        requestBody.add("age", 12);
        ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);

        System.out.println(response.getStatusCode());
        System.out.println(response.getBody());
    }

    /**
     * 測試JSON格式請求體Body方式POST請求
     */
    @Test
    public void sayHelloBody() {
        String url = "http://127.0.0.1:8080/test/sayHelloBody";
        JSONObject requestBody = new JSONObject();
        requestBody.put("name", "Logan");
        requestBody.put("age", 16);
        ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);

        System.out.println(response.getStatusCode());
        System.out.println(response.getBody());
    }

    /**
     * 測試上傳文件
     */
    @Test
    public void uploadFile() {
        String url = "http://127.0.0.1:8080/test/uploadFile";
        MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>();
        requestBody.add("uploadPath", "G:\\Temp\\Test");
        requestBody.add("file", new FileSystemResource("G:\\Java\\JavaStyle.xml"));
        requestBody.add("file2", new FileSystemResource("G:\\Java\\jad.exe"));

        ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);

        System.out.println(response.getStatusCode());
        System.out.println(response.getBody());
    }

    @Test
    public void downloadFile() {
        try {
            String url = "http://127.0.0.1:8080/test/downloadFile?filePath={filePath}&fileName={fileName}";

            String filePath = "G:\\Java";
            String fileName = "JavaStyle.xml";

            ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class, filePath, fileName);
            System.out.println(response.getStatusCode());
            System.out.println(response.getHeaders().getContentType());

            // 如果返回時文本內容，則直接輸出
            if ("text/html;charset=UTF-8".equals(response.getHeaders().getContentType().toString())) {
                System.out.println(new String(response.getBody(), "UTF-8"));
            }

            // 輸出響應內容到本地文件
            else {

                File file = new File("G:\\Temp\\Test", fileName);
                if (HttpStatus.OK.equals(response.getStatusCode())) {
                    FileUtils.writeByteArrayToFile(file, response.getBody());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 測試下載阿里巴巴的fastjson-1.2.56.jar
     */
    @Test
    public void downloadFile2() {
        try {
            String url = "http://central.maven.org/maven2/com/alibaba/fastjson/1.2.56/fastjson-1.2.56.jar";

            ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class);
            System.out.println(response.getStatusCode());

            // 下載文件路徑，可根據本地磁盤位置選擇下載路徑
            File file = new File("G:\\Temp\\Test\\fastjson-1.2.56.jar");
            if (HttpStatus.OK.equals(response.getStatusCode())) {
                FileUtils.writeByteArrayToFile(file, response.getBody());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

測試實體類

package com.java.entity;

/**
 * 測試實體類
 * 
 * @author Logan
 * @createDate 2019-02-08
 *
 */
public class Person {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

   UploadConfig.java

package com.java.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

/**
 * 上傳文件配置
 * 
 * @author Logan
 * @createDate 2019-02-08
 *
 */
@Configuration
public class UploadConfig {

    @Bean
    public CommonsMultipartResolver multipartResolver() {
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();

        // 設置最大上傳文件大小為4GB
        multipartResolver.setMaxUploadSize(4294967296l);
        return multipartResolver;
    }

}

 TestController.java

package com.java.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import com.java.entity.Person;

/**
 * 測試服務器測試接口類
 * 
 * @author Logan
 * @createDate 2019-02-08
 *
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private HttpServletRequest request;

    @GetMapping("/{name}")
    public Person test(@PathVariable("name") String name, int age) {
        String appId = request.getHeader("appId");
        System.out.println("appId: " + appId);

        Person person = new Person();
        person.setName(name);
        person.setAge(age);
        System.out.println(person);

        return person;
    }

    @PostMapping("/sayHello")
    public Person sayHello(Person person) {
        System.out.println(person);
        return person;
    }

    @PostMapping("/sayHelloBody")
    public Person sayHelloBody(@RequestBody Person person) {
        System.out.println(person);
        return person;
    }

    @RequestMapping("/uploadFile")
    public Map<String, Object> uploadFile(@RequestParam(required = true) CommonsMultipartFile file, @RequestParam(required = true) CommonsMultipartFile file2, String uploadPath) {
        Map<String, Object> result = new HashMap<String, Object>();
        try {

            // 上傳文件
            File path = new File(uploadPath);
            if (!path.isDirectory() || !path.exists()) {
                path.mkdirs();
            }
            File outFile = new File(uploadPath, file.getOriginalFilename());
            file.transferTo(outFile);

            File outFile2 = new File(uploadPath, file2.getOriginalFilename());
            file2.transferTo(outFile2);

            List<String> files = new ArrayList<>();
            files.add(outFile.getAbsolutePath());
            files.add(outFile2.getAbsolutePath());

            result.put("successful", true);
            result.put("files", files);
        } catch (Exception e) {
            e.printStackTrace();
            result.put("successful", false);
            result.put("msg", e.getMessage());
        }
        return result;
    }

    @GetMapping("/downloadFile")
    public void downloadFile(HttpServletResponse response, String filePath, String fileName) {
        File file = new File(filePath, fileName);
        if (file.exists() && file.isFile()) {

            try (
                    OutputStream out = response.getOutputStream();
                    FileInputStream in = new FileInputStream(file);
            ) {

                // 對文件名進行URL轉義，防止中文亂碼
                fileName = URLEncoder.encode(fileName, "UTF-8");

                // 空格用URLEncoder.encode轉義后會變成"+"，所以要替換成"%20"，瀏覽器會解碼回空格
                fileName = fileName.replace("+", "%20");

                // "+"用URLEncoder.encode轉義后會變成"%2B"，所以要替換成"+"，瀏覽器會解碼回"+"
                fileName = fileName.replace("%2B", "+");
                response.setContentType("application/x-msdownload;charset=UTF-8");
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
                IOUtils.copy(in, out);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 無法下載時給出提示信息
        else {
            response.setContentType("text/html;charset=UTF-8");

            try (
                    PrintWriter writer = response.getWriter();
            ) {
                writer.write("找不到對應文件，請確認后重試！");
                writer.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

7.   運行 TestServerStarter.java ，啟動測試服務器。

springboot中的restTemplate工具類

/**
 * RestTemplate 工具類
 * @author: author
 * @create: 2019-06-05 14:06
 **/
public class RestTemplateUtil {
 
    private static class SingletonRestTemplate {
        static final RestTemplate INSTANCE = new RestTemplate();
    }
 
    private RestTemplateUtil() {
    }
 
 
    public static RestTemplate getInstance() {
        return SingletonRestTemplate.INSTANCE;
    }
 
    /**
     * post 請求
     * @param url 請求路徑
     * @param data body數據
     * @param token JWT所需的Token，不需要的可去掉
     * @return
     */
    public static String post(String url, String data, String token) {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Accept", "application/json");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/json; charset=UTF-8");
        if (token != null) {
            headers.add("Authorization", token);
        }
        HttpEntity<String> requestEntity = new HttpEntity<>(data, headers);
        return RestTemplateUtil.getInstance().postForObject(url, requestEntity, String.class);
    }
 
    /**
     * get 請求
     * @param url 請求路徑
     * @param token JWT所需的Token，不需要的可去掉
     * @return
     */
    public static  String get(String url, String token) {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Accept", "application/json");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/json; charset=UTF-8");
        if (token != null) {
            headers.add("Authorization", token);
        }
        HttpEntity<String> requestEntity = new HttpEntity<>(null, headers);
        ResponseEntity<String> response = RestTemplateUtil.getInstance().exchange(url, HttpMethod.GET, requestEntity, String.class);
        String responseBody = response.getBody();
        return responseBody;
    }
}