RestTemplateUtils的 使用

 在開發中遇到業務系統調用其他業務系統的接口，不能前端直接調用，需要在後端轉發一次。

最開始用的httpclient的方式，後經同事點撥，換成更好用的RestTemplate。

工具類 來自 Spring 遠程調用工具類RestTemplateUtils

package com.dse.ncysgc.util;

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 wangzhy
 * @createDate 2019-11-28
 *
 */
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;
    }

}

相關的返回對象封裝類

• ResultMessage

package com.dse.ncysgc.common.vo;

import java.io.Serializable;

/**
 * @Description:
 * @Author : wangzhy
 * @Date: 2018/2/1
 * @Version 1.0
 */
public class ResultMessage implements Serializable {
    private static final long serialVersionUID = 2384408524681014178L;
    protected String msg;

    ResultMessage() {
    }

    public ResultMessage(String msg) {
        this.msg = msg;
    }

    public String getMsg() {
        return this.msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

• ResultStatus

package com.dse.ncysgc.common.vo;

/**
 * @Description:
 * @Author : wangzhy
 * @Date: 2018/2/1
 * @Version 1.0
 */
public enum ResultStatus {
    FAILURE(Integer.valueOf(0), "失敗"),
    SUCCESS(Integer.valueOf(1), "成功");

    private Integer status;
    private String desc;

    private ResultStatus(Integer status, String desc) {
        this.status = status;
        this.desc = desc;
    }

    public Integer status() {
        return this.status;
    }

    public String desc() {
        return this.desc;
    }

}

• ResultVo

package com.dse.ncysgc.common.vo;

import java.io.Serializable;

/**
 * @version v 1.0.
 * @Descrption 請求接口返回對象
 * @Author wangzhy
 * @Date 2019-11-26
 */
public class ResultVo<T> implements Serializable {

    private T data;
    private Integer status;
    private ResultMessage message;

    private ResultVo() {
        this.status = ResultStatus.SUCCESS.status();
    }

    private ResultVo(Integer status) {
        this.status = ResultStatus.SUCCESS.status();
        this.status = status;
    }

    private ResultVo(Integer status, ResultMessage message) {
        this.status = ResultStatus.SUCCESS.status();
        this.status = status;
        this.message = message;
    }

    private ResultVo(T data, Integer status) {
        this.status = ResultStatus.SUCCESS.status();
        this.data = data;
        this.status = status;
    }

    private ResultVo(T data, Integer status, ResultMessage message) {
        this.status = ResultStatus.SUCCESS.status();
        this.data = data;
        this.status = status;
        this.message = message;
    }

    public T getData() {
        return this.data;
    }

    public ResultMessage getMessage() {
        return this.message;
    }

    public Integer getStatus() {
        return this.status;
    }

    public static <T> ResultVo<T> success(T data) {
        return new ResultVo(data, ResultStatus.SUCCESS.status());
    }

    public static <T> ResultVo<T> success() {
        return new ResultVo();
    }

    public static <T> ResultVo<T> success(T data, ResultMessage message) {
        return new ResultVo(data, ResultStatus.SUCCESS.status(), message);
    }

    public static <T> ResultVo<T> failure(T data, ResultMessage message) {
        return new ResultVo(data, ResultStatus.FAILURE.status(), message);
    }

    public static <T> ResultVo<T> failure(ResultMessage message) {
        return new ResultVo(ResultStatus.FAILURE.status(), message);
    }

    public static <T> ResultVo<T> failure() {
        return new ResultVo(ResultStatus.FAILURE.status());
    }

    public static ResultVo<Void> voidResult() {
        return new ResultVo();
    }

    @Override
    public String toString() {
        return "ResultVo{" +
                "data=" + data +
                ", status=" + status +
                ", message=" + message +
                '}';
    }
}

業務類

package com.dse.ncysgc.common.controller;

import com.dse.ncysgc.common.vo.DseUser;
import com.dse.ncysgc.common.vo.ResultMessage;
import com.dse.ncysgc.common.vo.ResultVo;
import com.dse.ncysgc.util.HttpClientUtil;
import com.dse.ncysgc.util.JwtTokenUtil;
import com.dse.ncysgc.util.NyConstant;
import com.dse.ncysgc.util.RestTemplateUtils;
import com.dse.security.config.core.DseUserInfoServiceI;
import org.apache.poi.ss.formula.functions.T;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * @version v 1.0.
 * @Descrption 1, 通過調用命令接口 執行rtu opc 相關命令
 * @Author wangzhy
 * @Date 2019-11-26
 */
@RestController
@RequestMapping("/iotCmdCtrl")
public class IotCmdCtroller {

    Logger logger = LoggerFactory.getLogger(IotCmdCtroller.class);

    private static final String staticToken = "TsLNd&2HQQ3rR&xkndMs#ftAsi8pqnv5";

    @Value("${interface.rtu.url}")
    private String rtuUrl;

    @Value("${interface.opc.url}")
    private String opcUrl;

    /**
     * 閥門控制
     * 調用該接口將會向RTU發送控制閥門開度命令
     *
     * @param map
     * @param userInfoServiceI
     * @return
     */
    @RequestMapping("/valveControl")
    @ResponseBody
    public ResultVo valveControl(@RequestBody Map<String, Object> map, DseUserInfoServiceI userInfoServiceI) {
        try {
            String url = rtuUrl + NyConstant.IOTINTERFACE.INTERFACE_RTU_CONTROL_VALVE;


            HttpHeaders headers = new HttpHeaders();
            headers.set("X-Token","TsLNd&2HQQ3rR&xkndMs#ftAsi8pqnv5");

            ResponseEntity<ResultVo> responseEntity = RestTemplateUtils.post(url,headers,map,ResultVo.class);

            return   responseEntity.getBody();
        } catch (Exception e) {
            logger.error("水泵控制失敗!", e);
            return ResultVo.failure(new ResultMessage("水泵控制失敗"));
        }
    }

    /**
     * RTU  水泵控制
     * 調用該接口將會向RTU發送控制水泵開關命令
     *
     * @param map{  stcd：測站編碼
     *               status: {key：水泵編號，value：水泵開關狀態，開關值爲0或1}
     *            }
     *  X-Token ： 通行令牌
     * @param userInfoServiceI
     * @return
     */
    @RequestMapping("/pumpControl")
    @ResponseBody
    public ResultVo pumpControl(@RequestBody Map<String, Object> map, DseUserInfoServiceI userInfoServiceI) {
        try {
            String url = rtuUrl + NyConstant.IOTINTERFACE.INTERFACE_RTU_CONTROL_PUMP;

            HttpHeaders headers = new HttpHeaders();
            headers.set("X-Token","TsLNd&2HQQ3rR&xkndMs#ftAsi8pqnv5");

            ResponseEntity<ResultVo> responseEntity = RestTemplateUtils.post(url,headers,map,ResultVo.class);

            return responseEntity.getBody();
        } catch (Exception e) {
            logger.error("水泵控制失敗!", e);
            return ResultVo.failure(new ResultMessage("水泵控制失敗!"));
        }
    }

    /**
     * 查詢命令執行狀態
     * state爲狀態碼，0表示準備發送，1表示正在執行，2表示執行成功，3表示執行失敗，4表示該命令已取消
     *
     * @param map
     * @param userInfoServiceI
     * @return
     */
    @RequestMapping("/queryEvent")
    @ResponseBody
    public ResultVo queryEvent(@RequestBody Map<String, Object> map, DseUserInfoServiceI userInfoServiceI) {
        try {
            String url = rtuUrl + NyConstant.IOTINTERFACE.INTERFACE_RTU_QUERY_EVENT;

            HttpHeaders headers = new HttpHeaders();
            headers.set("X-Token","TsLNd&2HQQ3rR&xkndMs#ftAsi8pqnv5");

            ResponseEntity<ResultVo> responseEntity = RestTemplateUtils.post(url,headers,map,ResultVo.class);

            return responseEntity.getBody();
        } catch (Exception e) {
            logger.error("查詢命令執行狀態失敗!", e);
            return ResultVo.failure(new ResultMessage("查詢命令執行狀態失敗!"));
        }
    }

    /**
     * 向OPC發送控制指令或者修改參數
     * 調用該接口將會向OPC發送控制或修改參數命令
     * @param map
     * @param userInfoServiceI
     * @return
     */
    @RequestMapping("/opcCommand")
    @ResponseBody
    public ResultVo opcCommand(@RequestBody Map<String, Object> map, DseUserInfoServiceI userInfoServiceI){
        try {
            String url = opcUrl + NyConstant.IOTINTERFACE.INTERFACE_OPC_COMMAND;

            HttpHeaders headers = new HttpHeaders();
            headers.set("X-Token","TsLNd&2HQQ3rR&xkndMs#ftAsi8pqnv5");

            ResponseEntity<ResultVo> responseEntity = RestTemplateUtils.post(url,headers,map,ResultVo.class);

            return responseEntity.getBody();
        } catch (Exception e) {
            logger.error("向OPC發送控制指令或者修改參數失敗!", e);
            return ResultVo.failure(new ResultMessage("向OPC發送控制指令或者修改參數失敗!"));
        }
    }
}

小幺雞調用結果