RestTemplate 工具類以及攔截器配置打印調用日志

RestTemplate工具類

/**
 * RestTemplate 遠程調用工具類
 */
public class RestTemplateUtil {
    private static final RestTemplate restTemplate = SpringContextHolder.getBean(RestTemplate.class);


    // ----------------------------------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;
    }

}

攔截器配置

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getInterceptors().add(new LoggingClientHttpRequestInterceptor());
        return restTemplate;
    }
}

@Slf4j
class LoggingClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        traceRequest(request, body);
        ClientHttpResponse response = execution.execute(request, body);
        response = (ClientHttpResponse) Proxy.newProxyInstance(response.getClass().getClassLoader(), new Class[]{ClientHttpResponse.class}, new ClientHttpResponseHandler(response));
        traceResponse(response);
        return response;
    }

    private void traceRequest(HttpRequest request, byte[] body) throws IOException {
        log.info("===========================request begin================================================");
        log.info("URI         : {}", request.getURI());
        log.info("Method      : {}", request.getMethod());
        log.info("Headers     : {}", request.getHeaders());
        log.info("Request body: {}", new String(body, "UTF-8"));
        log.info("==========================request end================================================");
    }

    private void traceResponse(ClientHttpResponse response) throws IOException {
        StringBuilder inputStringBuilder = new StringBuilder();
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), StandardCharsets.UTF_8))) {
            String line = bufferedReader.readLine();
            while (line != null) {
                inputStringBuilder.append(line);
                inputStringBuilder.append('\n');
                line = bufferedReader.readLine();
            }
        }
        log.info("============================response begin==========================================");
        log.info("Status code  : {}", response.getStatusCode());
        log.info("Status text  : {}", response.getStatusText());
        log.info("Headers      : {}", response.getHeaders());
        log.info("Response body: {}", inputStringBuilder.toString());//WARNING: comment out in production to improve performance
        log.info("=======================response end=================================================");
    }

    private static class ClientHttpResponseHandler implements InvocationHandler {
        private static final String methodName = "getBody";
        private ClientHttpResponse clientHttpResponse;
        private byte[] body;

        ClientHttpResponseHandler(ClientHttpResponse clientHttpResponse) {
            this.clientHttpResponse = clientHttpResponse;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (StrUtil.equals(methodName, method.getName())) {
                if (Objects.isNull(this.body)) {
                    this.body = StreamUtils.copyToByteArray(this.clientHttpResponse.getBody());
                }
                return new ByteArrayInputStream(this.body == null ? new byte[0] : this.body);
            }
            return method.invoke(this.clientHttpResponse, args);
        }
    }
}