在開發中遇到業務系統調用其他業務系統的接口，不能前端直接調用，需要在後端轉發一次。
最開始用的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發送控制指令或者修改參數失敗!"));
}
}
}
小幺雞調用結果
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)