RestTemplate报错打印异常信息

public class EraseTypeResponseEntity extends ResponseEntity {

    private String msg;

    EraseTypeResponseEntity(String msg, MultiValueMap<String, String> headers, HttpStatus status) {
        super(null, headers, status);
        this.msg = msg;
    }

    @Override
    public Object getBody() {
        return this.msg;
    }
}

public class NoErrorResultErrorHandler extends DefaultResponseErrorHandler {

    @Override
    public void handleError(ClientHttpResponse response) {
    }
}

public class NoExceptionRestTemplateResponseEntityExtractor<T> implements ResponseExtractor<ResponseEntity<T>> {

    private static final Logger log = LoggerFactory.getLogger(NoExceptionRestTemplateResponseEntityExtractor.class);
    private final HttpMessageConverterExtractor<T> delegate;

    NoExceptionRestTemplateResponseEntityExtractor(Type responseType, List<HttpMessageConverter<?>> converters) {
        if (responseType != null && Void.class != responseType) {
            this.delegate = new HttpMessageConverterExtractor<>(responseType, converters);
        } else {
            this.delegate = null;
        }
    }

    @Override
    public ResponseEntity<T> extractData(ClientHttpResponse response) throws IOException {
        if (this.delegate != null) {
            T body = null;
            try {
                body = this.delegate.extractData(response);
            } catch (RuntimeException e) {
                String content;
                try {
                    content = StreamUtils.copyToString(response.getBody(), UTF_8);
                    log.error("请求接口时返回[" + content + "],无法解析返回值", e);
                } catch (Exception exception) {
                    content = "";
                    log.error("请求接口时返回未知结果,无法解析返回值", exception);
                }
                return new EraseTypeResponseEntity(content, response.getHeaders(), response.getStatusCode());
            }
            return new ResponseEntity<>(body, response.getHeaders(), response.getStatusCode());
        } else {
            return new ResponseEntity<>(response.getHeaders(), response.getStatusCode());
        }
    }
}

public class RestTemplateProxy extends RestTemplate {

    @Override
    public <T> ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType) {
        return new NoExceptionRestTemplateResponseEntityExtractor<>(responseType, getMessageConverters());
    }

    @Override
    protected <T> T doExecute(URI url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor) throws RestClientException {
        logger.info("发起请求" + method.toString() + " " + url.toString());
        T t = super.doExecute(url, method, requestCallback, responseExtractor);
        return t;
    }
}

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(ObjectMapper objectMapper) {
        RestTemplate restTemplate = new RestTemplateProxy();
        restTemplate.setErrorHandler(new NoErrorResultErrorHandler());
        return restTemplate;
    }


    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}