Java 封装请求响应助手工具类

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;


@Slf4j
@Component
public class SendHandler {

    @Resource(name = "proxyRestTemplate")
    private RestTemplate proxyRestTemplate;

    private static final String X_SECURITY = "X-Security";
    private static final String X_SIGN = "X-Sign";
    private static final String X_TIME = "X-Time";
    private static final String X_TRACE = "X-Trace";

    /**
     * 域名地址
     */
    private static final String DOMAIN = "https://test-xxx.com";


    public <P, D> Response<D> send(String url, Request<P> request,TypeReference<D> typeReference) {
        log.info("request : {}", request.toJson());

        /*
         * JSON 序列化和反序列化工具包，此处使用 jackson 模拟，实际场景可以自行选择 JSON 工具包
         */
        ObjectMapper objectMapper = new ObjectMapper();

        /*
         * 参数明文：参数对象的 json 序列化后的字符串的明文
         */
        String paramPlains;
        try {
            paramPlains = objectMapper.writeValueAsString(request.getParam());
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        System.out.println("request param plains" + " : " + paramPlains);

        /*
         * 参数密文
         */
        String paramCipher;
        try {
            assert paramPlains != null;
            paramCipher = AesUtil.encrypt(paramPlains);
        } catch (Exception e) {
            log.error("{}", e);
            throw new RuntimeException(e);
        }
        System.out.println("request param cipher" + " : " + paramCipher);

        /*
         * 请求签名
         */
        String requestSign;
        try {
            assert paramCipher != null;
            requestSign = HashUtil.sha256(paramCipher);
        } catch (Exception e) {
            log.error("{}", e);
            throw new RuntimeException(e);
        }


        Map<String, Object> requestMap = new LinkedHashMap<>();
        requestMap.put("param", paramCipher);

        String requestBody;
        try {
            requestBody = objectMapper.writeValueAsString(requestMap);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        System.out.println("request body" + " : " + requestBody);

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
        httpHeaders.set(X_SECURITY, "AES");
        httpHeaders.set(X_SIGN, requestSign);
        httpHeaders.set(X_TIME, ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.RFC_1123_DATE_TIME));
        httpHeaders.set(X_TRACE, UUID.randomUUID().toString().replaceAll("-", ""));
        System.out.println("request X-Sign" + " : " + requestSign);
        HttpEntity<String> httpEntity = new HttpEntity<String>(requestBody, httpHeaders);

        ResponseEntity<String> responseEntity;


        try {
            ParameterizedTypeReference<String> respType = new ParameterizedTypeReference<>() {
            };

            responseEntity = proxyRestTemplate.exchange(url, HttpMethod.POST, httpEntity, respType, String.class);
        } catch (Exception var11) {
            log.error(var11.getMessage(), var11);
            throw new PaasException(PaasError.INVOKE_CLOUD_API_EXCEPTION, "cloud inner gateway : [" + url + "] " + var11.getMessage());
        }

        HttpStatus httpStatus = responseEntity.getStatusCode();
        if (!httpStatus.is2xxSuccessful()) {
            throw new PaasException(PaasError.HTTP_STATUS_IS_NOT_2XX, " cloud inner gateway : [" + url + "] " + httpStatus);
        }
        log.info("res {}", responseEntity);
        String responseStr = responseEntity.getBody();
        Map<String, Object> responseMap;
        try {
            responseMap = objectMapper.readValue(responseStr, LinkedHashMap.class);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        if (null == responseMap || responseMap.isEmpty()) {
            System.out.println("response map" + " is empty !");
        }

        /*
         * 响应码，默认 00 表示请求成功
         */
        assert responseMap != null;
        String code = (String) responseMap.get("code");
        System.out.println("response code" + " : " + code);
        if (!"00".equals(code)) {
            System.out.println("response code" + " is not 000000 !");
        }
        /*
         * 响应信息
         */
        String message = (String) responseMap.get("message");
        System.out.println("response message" + " : " + message);
        /*
         * 响应 数据密文
         */
        String dataCipher = (String) responseMap.get("data");
        System.out.println("response data cipher" + " : " + dataCipher);
        if (null == dataCipher || dataCipher.isEmpty()) {
            System.out.println("response data cipher" + " is empty !");
        }

        /*
         * 响应 数据明文
         */
        String dataPlains;
        D data;
        try {
            dataPlains = AesUtil.decrypt(dataCipher);
            log.info("dataPlains  {} ", dataPlains);
            data=objectMapper.readValue(dataPlains,typeReference);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        log.info("response data responseMap {} ", responseMap);
        Response<D> response = new Response<D>();
        response.setCode(code);
        response.setMessage(message);
        response.setData(data);
        log.info("{}", response.toJson());
        return response;

    }
}