微服务中如何使用RestTemplate优雅调用API（拦截器、异常处理、消息转换）

关注我，可以获取最新知识、经典面试题以及微服务技术分享

在微服务中， rest 服务互相调用是很普遍的，我们该如何优雅地调用，其实在Spring框架使用 RestTemplate 类可以优雅地进行 rest 服务互相调用，它简化了与 http 服务的通信方式，统一了 RESTful 的标准，封装了 http 链接，操作使用简便，还可以自定义RestTemplate所需的模式。其中：

• RestTemplate 默认使用 HttpMessageConverter 实例将 HTTP 消息转换成 POJO 或者从 POJO 转换成 HTTP 消息。默认情况下会注册主 mime 类型的转换器，但也可以通过 setMessageConverters 注册自定义转换器。
• RestTemplate 使用了默认的 DefaultResponseErrorHandler ，对40X Bad Request 或50X internal 异常 error 等错误信息捕捉。
• RestTemplate 还可以使用拦截器 interceptor ，进行对请求链接跟踪，以及统一head的设置。

其中， RestTemplate 还定义了很多的 REST 资源交互的方法，其中的大多数都对应于 HTTP 的方法，如下：

1. RestTemplate源码

1.1 默认调用链路

restTemplate 进行API调用时，默认调用链：

###########1.使用createRequest创建请求########
resttemplate->execute()->doExecute()
HttpAccessor->createRequest()
//获取拦截器Interceptor，InterceptingClientHttpRequestFactory，SimpleClientHttpRequestFactory
InterceptingHttpAccessor->getRequestFactory() 
//获取默认的SimpleBufferingClientHttpRequest
SimpleClientHttpRequestFactory->createRequest()

#######2.获取响应response进行处理###########
AbstractClientHttpRequest->execute()->executeInternal()
AbstractBufferingClientHttpRequest->executeInternal()

###########3.异常处理#####################
resttemplate->handleResponse()

##########4.响应消息体封装为java对象#######
HttpMessageConverterExtractor->extractData()

1.2 restTemplate->doExecute()

在默认调用链中， restTemplate 进行API调用都会调用 doExecute 方法，此方法主要可以进行如下步骤：

1） 使用 createRequest 创建请求，获取响应

2） 判断响应是否异常，处理异常

3） 将响应消息体封装为java对象

@Nullable
protected  T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
        @Nullable ResponseExtractor responseExtractor) throws RestClientException {

    Assert.notNull(url, "URI is required");
    Assert.notNull(method, "HttpMethod is required");
    ClientHttpResponse response = null;
    try {
        //使用createRequest创建请求
        ClientHttpRequest request = createRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        }
        //获取响应response进行处理
        response = request.execute();
        //异常处理
        handleResponse(url, method, response);
        //响应消息体封装为java对象
        return (responseExtractor != null ? responseExtractor.extractData(response) : null);
    }catch (IOException ex) {
        String resource = url.toString();
        String query = url.getRawQuery();
        resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
        throw new ResourceAccessException("I/O error on " + method.name() +
                " request for \"" + resource + "\": " + ex.getMessage(), ex);
    }finally {
        if (response != null) {
            response.close();
        }
    }
}

1.3 InterceptingHttpAccessor->getRequestFactory()

在默认调用链中， InterceptingHttpAccessor的getRequestFactory() 方法中，如果没有设置 interceptor 拦截器，就返回默认的 SimpleClientHttpRequestFactory ，反之，返回 InterceptingClientHttpRequestFactory 的 requestFactory ，可以通过 resttemplate.setInterceptors 设置自定义拦截器 interceptor 。

//Return the request factory that this accessor uses for obtaining client request handles.
public ClientHttpRequestFactory getRequestFactory() {
        //获取拦截器interceptor(自定义的)
        List interceptors = getInterceptors();
        if (!CollectionUtils.isEmpty(interceptors)) {
            ClientHttpRequestFactory factory = this.interceptingRequestFactory;
            if (factory == null) {
                factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors);
                this.interceptingRequestFactory = factory;
            }
            return factory;
        }
        else {
            return super.getRequestFactory();
        }
    }

然后再调用 SimpleClientHttpRequestFactory的createRequest 创建连接：

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    HttpURLConnection connection = openConnection(uri.toURL(), this.proxy);
    prepareConnection(connection, httpMethod.name());

    if (this.bufferRequestBody) {
        return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming);
    }
    else {
        return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming);
    }
}

1.4 resttemplate->handleResponse()

在默认调用链中， resttemplate的handleResponse ，响应处理，包括异常处理，而且异常处理可以通过调用 setErrorHandler 方法设置自定义的 ErrorHandler ，实现对请求响应异常的判别和处理。自定义的 ErrorHandler 需实现 ResponseErrorHandler 接口，同时 Spring boot 也提供了默认实现 DefaultResponseErrorHandler ，因此也可以通过继承该类来实现自己的 ErrorHandler 。

DefaultResponseErrorHandler 默认对40X Bad Request 或50X internal 异常 error 等错误信息捕捉。如果想捕捉服务本身抛出的异常信息，需要通过自行实现 RestTemplate 的 ErrorHandler 。

ResponseErrorHandler errorHandler = getErrorHandler();
               //判断响应是否有异常
    boolean hasError = errorHandler.hasError(response);
    if (logger.isDebugEnabled()) {
        try {
            int code = response.getRawStatusCode();
            HttpStatus status = HttpStatus.resolve(code);
            logger.debug("Response " + (status != null ? status : code));
        }catch (IOException ex) {
            // ignore
        }
    }
    //有异常进行异常处理
    if (hasError) {
        errorHandler.handleError(url, method, response);
    }
}

1.5 HttpMessageConverterExtractor->extractData()

在默认调用链中， HttpMessageConverterExtractor 的 extractData 中进行响应消息体封装为 java 对象，就需要使用 message 转换器，可以通过追加的方式增加自定义的 messageConverter ：先获取现有的 messageConverter ，再将自定义的 messageConverter 添加进去。

根据 restTemplate 的 setMessageConverters 的源码可得，使用追加的方式可防止原有的 messageConverter 丢失，源码：

public void setMessageConverters(List<HttpMessageConverter> messageConverters) {
        //检验
        validateConverters(messageConverters);
        // Take getMessageConverters() List as-is when passed in here
        if (this.messageConverters != messageConverters) {
            //先清除原有的messageConverter
            this.messageConverters.clear();
            //后加载重新定义的messageConverter
            this.messageConverters.addAll(messageConverters);
        }
    }

HttpMessageConverterExtractor的extractData 源码：

MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);
    if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {
        return null;
    }
    //获取到response的ContentType类型
    MediaType contentType = getContentType(responseWrapper);

    try {
        //依次循环messageConverter进行判断是否符合转换条件，进行转换java对象
        for (HttpMessageConverter messageConverter : this.messageConverters) {
        //会根据设置的返回类型responseType和contentType参数进行匹配，选择合适的MessageConverter
            if (messageConverter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter genericMessageConverter =
                        (GenericHttpMessageConverter) messageConverter;
                if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
                    if (logger.isDebugEnabled()) {
                        ResolvableType resolvableType = ResolvableType.forType(this.responseType);
                        logger.debug("Reading to [" + resolvableType + "]");
                    }
                    return (T) genericMessageConverter.read(this.responseType, null, responseWrapper);
                }
            }
            if (this.responseClass != null) {
                if (messageConverter.canRead(this.responseClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        String className = this.responseClass.getName();
                        logger.debug("Reading to [" + className + "] as \"" + contentType + "\"");
                    }
                    return (T) messageConverter.read((Class) this.responseClass, responseWrapper);
                }
            }
        }
    }
    .....
}

1.6 contentType与messageConverter之间的关系

在 HttpMessageConverterExtractor 的 extractData 方法中看出，会根据 contentType 与 responseClass 选择 messageConverter 是否可读、消息转换。关系如下：

2. springboot集成RestTemplate

根据上述源码的分析学习，可以轻松，简单地在项目进行对RestTemplate进行优雅地使用，比如增加自定义的异常处理、 MessageConverter 以及拦截器 interceptor 。本文使用示例 demo ，详情请查看接下来的内容。

2.1. 导入依赖：（RestTemplate集成在Web Start中）

  org.springframework.boot
  spring-boot-starter-web
  2.2.0.RELEASE



  org.projectlombok
  lombok
  1.18.10
  provided

2.2. RestTemplat配置：

• 使用 ClientHttpRequestFactory 属性配置RestTemplat参数，比如 ConnectTimeout ， ReadTimeout ;
• 增加自定义的 interceptor 拦截器和异常处理;
• 追加 message 转换器;
• 配置自定义的异常处理.

@Configuration
public class RestTemplateConfig {

    @Value("${resttemplate.connection.timeout}")
    private int restTemplateConnectionTimeout;
    @Value("${resttemplate.read.timeout}")
    private int restTemplateReadTimeout;

    @Bean
    //@LoadBalanced
    public RestTemplate restTemplate( ClientHttpRequestFactory simleClientHttpRequestFactory) {
        RestTemplate restTemplate = new RestTemplate();
        //配置自定义的message转换器
        List<HttpMessageConverter> messageConverters = restTemplate.getMessageConverters();
        messageConverters.add(new CustomMappingJackson2HttpMessageConverter());
        restTemplate.setMessageConverters(messageConverters);
        //配置自定义的interceptor拦截器
        List interceptors=new ArrayList();
        interceptors.add(new HeadClientHttpRequestInterceptor());
        interceptors.add(new TrackLogClientHttpRequestInterceptor());
        restTemplate.setInterceptors(interceptors);
        //配置自定义的异常处理
        restTemplate.setErrorHandler(new CustomResponseErrorHandler());
        restTemplate.setRequestFactory(simleClientHttpRequestFactory);

        return restTemplate;
    }

    @Bean
    public ClientHttpRequestFactory simleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory reqFactory= new SimpleClientHttpRequestFactory();
        reqFactory.setConnectTimeout(restTemplateConnectionTimeout);
        reqFactory.setReadTimeout(restTemplateReadTimeout);
        return reqFactory;
    }
}

2.3. 组件(自定义异常处理、interceptor拦截器、message转化器)

自定义 interceptor 拦截器，实现 ClientHttpRequestInterceptor 接口

• 自定义 TrackLogClientHttpRequestInterceptor ，记录 resttemplate 的 request 和 response 信息，可进行追踪分析；
• 自定义 HeadClientHttpRequestInterceptor ，设置请求头的参数。API发送各种请求，很多请求都需要用到相似或者相同的Http Header。如果在每次请求之前都把 Header 填入 HttpEntity/RequestEntity ，这样的代码会显得十分冗余，可以在拦截器统一设置。

TrackLogClientHttpRequestInterceptor：

/**
 * @Auther: ccww
 * @Date: 2019/10/25 22:48，记录resttemplate访问信息
 * @Description:   记录resttemplate访问信息
 */
@Slf4j
public class TrackLogClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        trackRequest(request,body);
        ClientHttpResponse httpResponse = execution.execute(request, body);
        trackResponse(httpResponse);
        return httpResponse;
    }

    private void trackResponse(ClientHttpResponse httpResponse)throws IOException {
        log.info("============================response begin==========================================");
        log.info("Status code  : {}", httpResponse.getStatusCode());
        log.info("Status text  : {}", httpResponse.getStatusText());
        log.info("Headers      : {}", httpResponse.getHeaders());
        log.info("=======================response end=================================================");
    }

    private void trackRequest(HttpRequest request, byte[] body)throws UnsupportedEncodingException {
        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 ========");
    }
}

HeadClientHttpRequestInterceptor：

@Slf4j
public class HeadClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
    public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
       log.info("#####head handle########");
        HttpHeaders headers = httpRequest.getHeaders();
        headers.add("Accept", "application/json");
        headers.add("Accept-Encoding", "gzip");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/json; charset=UTF-8");
        ClientHttpResponse response = clientHttpRequestExecution.execute(httpRequest, bytes);
        HttpHeaders headersResponse = response.getHeaders();
        headersResponse.add("Accept", "application/json");
        return  response;
    }
}

自定义异常处理，可继承 DefaultResponseErrorHandler 或者实现 ResponseErrorHandler 接口：

• 实现自定义 ErrorHandler 的思路是根据响应消息体进行相应的异常处理策略，对于其他异常情况由父类 DefaultResponseErrorHandler 来进行处理。
• 自定义 CustomResponseErrorHandler 进行30x异常处理

CustomResponseErrorHandler:

/**
 * @Auther: Ccww
 * @Date: 2019/10/28 17:00
 * @Description:  30X的异常处理
 */
@Slf4j
public class CustomResponseErrorHandler extends DefaultResponseErrorHandler {
    @Override
    public boolean hasError(ClientHttpResponse response) throws IOException {
        HttpStatus statusCode = response.getStatusCode();
        if(statusCode.is3xxRedirection()){
            return true;
        }
        return super.hasError(response);
    }

    @Override
    public void handleError(ClientHttpResponse response) throws IOException {
        HttpStatus statusCode = response.getStatusCode();
        if(statusCode.is3xxRedirection()){
            log.info("########30X错误，需要重定向！##########");
            return;
        }
        super.handleError(response);
    }

}

自定义message转化器

/**
 * @Auther: Ccww
 * @Date: 2019/10/29 21:15
 * @Description: 将Content-Type:"text/html"转换为Map类型格式
 */
public class CustomMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {
    public CustomMappingJackson2HttpMessageConverter() {
        List mediaTypes = new ArrayList();
        mediaTypes.add(MediaType.TEXT_PLAIN);
        mediaTypes.add(MediaType.TEXT_HTML);  //加入text/html类型的支持
        setSupportedMediaTypes(mediaTypes);// tag6
    }

}

最后可关注公众号【Ccww笔记】，一起学习。加群，每天会分享干货，还有学习视频领取！