Spring - RestTemplate执行原理分析

什么是RestTemplate

Synchronous client to perform HTTP requests, exposing a simple, template method API over underlying HTTP client libraries such as the JDK HttpURLConnection, Apache HttpComponents, and others.

这是RestTemplate源码里对其自身的解释，从类名来看把类想设计成一个标准的模板，简单来说就是简化Http的请求以及响应的封装，并且执行了Restful原则。如果没有RestTemplate，我们可能使用更多的还是Apache HttpClient工具。另外从这个定义里我看到一个很重要的类HttpUrlConnection，这是RestTemplate与HTTP服务器通信的核心类。

RestTempate类结构

从类库中可以看出，这个类是一个很Spring的设计，继承抽象类InterceptingHttpAccessor，实现接口RestOperations。

RestTemplate执行流程图

开始分析之前，我们以RestTemplate#getForObject()为例，先浏览一下整个方法调用过程的执行流程图，几个关键步骤，看到其中的几个关键类，我会在后面详细说明这几个关键类。

RestTemplate构造函数

在看具体的执行http请求方法前，我们先看一下构造函数都做了那些工具。

public RestTemplate() {

    #设置各种messageConvert, 比如我们最常见的StringHttpMessageConverter。

    this.messageConverters.add(new ByteArrayHttpMessageConverter());

    this.messageConverters.add(new StringHttpMessageConverter());

    this.messageConverters.add(new ResourceHttpMessageConverter(false));

    try {

        this.messageConverters.add(new SourceHttpMessageConverter<>());

    }

    catch (Error err) {

        // Ignore when no TransformerFactory implementation is available

    }

    this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());

    if (romePresent) {

        this.messageConverters.add(new AtomFeedHttpMessageConverter());

        this.messageConverters.add(new RssChannelHttpMessageConverter());

    }

    if (jackson2XmlPresent) {

        this.messageConverters.add(new MappingJackson2XmlHttpMessageConverter());

    }

    else if (jaxb2Present) {

        this.messageConverters.add(new Jaxb2RootElementHttpMessageConverter());

    }

    if (jackson2Present) {

        this.messageConverters.add(new MappingJackson2HttpMessageConverter());

    }

    else if (gsonPresent) {

        this.messageConverters.add(new GsonHttpMessageConverter());

    }

    else if (jsonbPresent) {

        this.messageConverters.add(new JsonbHttpMessageConverter());

    }

    if (jackson2SmilePresent) {

        this.messageConverters.add(new MappingJackson2SmileHttpMessageConverter());

    }

    if (jackson2CborPresent) {

        this.messageConverters.add(new MappingJackson2CborHttpMessageConverter());

    }

    #设置UriTemplateHandler

    this.uriTemplateHandler = initUriTemplateHandler();

}

构造方法总结来说只做了两件事，添加HttpMessageConvert实现类，手动配置SpringMVC的时代，想必大家都知道HttpMessageConverter吧，顾名思义就是转换HTTP请求响应过程中的消息数据。第二就是初始化UriTemplateHandler，在initUriTemplateHanlder()方法中可以看到实际实例化的是DefaultUriBuilderFactory类并返回。

RestTemplat#getForObject()

我们现在开始沿着getForObject入口来分析一下执行一个HTTP Rest请求的流程到底是怎样的哈。

getForObject

#RestTemplate.getForObject

@Override

@Nullable

public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {

   RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);

   HttpMessageConverterExtractor<T> responseExtractor =

		new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);

   #这里传入requestCallback和responseExtractor，调用execute()

   return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);

}

execute()

#RestTemplate.execute

@Override

@Nullable

public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,

			@Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {

  URI expanded = getUriTemplateHandler().expand(url, uriVariables);

  #调用doExecute()

  return doExecute(expanded, method, requestCallback, responseExtractor);

}

doExecute()

@Nullable

protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,

			@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {

    Assert.notNull(url, "URI is required");

    Assert.notNull(method, "HttpMethod is required");

    ClientHttpResponse response = null;

    try {

        #1.生成请求

        ClientHttpRequest request = createRequest(url, method);

        if (requestCallback != null) {

            #2.设置header

            requestCallback.doWithRequest(request);

        }

        #3.执行请求

        response = request.execute();

        #4.处理响应

        handleResponse(url, method, response);

        #5.返回执行结果

        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();

        }

    }

}

HttpAccessor

doExecute()方法的第一个步骤就是创建ClientHttpRequest, 这是一个接口，那么这个方法执行完会创建那个实现类呢？ createRequest() 是父类HttpAccessor的方法，我们要先简单分析下HttpAcessor。

package org.springframework.http.client.support;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.logging.Log;

import org.springframework.core.annotation.AnnotationAwareOrderComparator;

import org.springframework.http.HttpLogging;

import org.springframework.http.HttpMethod;

import org.springframework.http.client.ClientHttpRequest;

import org.springframework.http.client.ClientHttpRequestFactory;

import org.springframework.http.client.ClientHttpRequestInitializer;

import org.springframework.http.client.SimpleClientHttpRequestFactory;

import org.springframework.util.Assert;

public abstract class HttpAccessor {

    protected final Log logger = HttpLogging.forLogName(getClass());

	private ClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();

	private final List<ClientHttpRequestInitializer> clientHttpRequestInitializers = new ArrayList<>();

	public void setRequestFactory(ClientHttpRequestFactory requestFactory) {

		Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");

		this.requestFactory = requestFactory;

	}

	public ClientHttpRequestFactory getRequestFactory() {

		return this.requestFactory;

	}

	public void setClientHttpRequestInitializers(

			List<ClientHttpRequestInitializer> clientHttpRequestInitializers) {

		if (this.clientHttpRequestInitializers != clientHttpRequestInitializers) {

			this.clientHttpRequestInitializers.clear();

			this.clientHttpRequestInitializers.addAll(clientHttpRequestInitializers);

			AnnotationAwareOrderComparator.sort(this.clientHttpRequestInitializers);

		}

	}

	public List<ClientHttpRequestInitializer> getClientHttpRequestInitializers() {

		return this.clientHttpRequestInitializers;

	}

    #在这个方法里会创建ClientHttpRequest实例并且返回。

	protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {

		ClientHttpRequest request = getRequestFactory().createRequest(url, method);

		initialize(request);

		if (logger.isDebugEnabled()) {

			logger.debug("HTTP " + method.name() + " " + url);

		}

		return request;

	}

	private void initialize(ClientHttpRequest request) {

		this.clientHttpRequestInitializers.forEach(initializer -> initializer.initialize(request));

	}

}

从HttpAccessor#createRequest()分析来看,会先调用getRequestFactory() 返回_SimpleClientHttpRequestFactory，然后调用SimpleClientHttpRequestFactory.createRequest()。但是这里我们忽略了一个环节，那就是**InterceptingHttpAccessor， **_这里我们需要再深吸一口气，再看看InterceptingHttpAccessor类。

SimpleClientHttpRequestFactory类结构图

InterceptingHttpAccessor

public abstract class InterceptingHttpAccessor extends HttpAccessor {

    #拦截器属性，可以自定义拦截器实现业务逻辑，当然玩过SpringCloud Ribbon调用，对这个属性再熟悉不过了。

	private final List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();

    #这个属性要和HttpAccessor.requestFactory呼应一下。

	@Nullable

	private volatile ClientHttpRequestFactory interceptingRequestFactory;

	public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {

		if (this.interceptors != interceptors) {

			this.interceptors.clear();

			this.interceptors.addAll(interceptors);

			AnnotationAwareOrderComparator.sort(this.interceptors);

		}

	}

	public List<ClientHttpRequestInterceptor> getInterceptors() {

		return this.interceptors;

	}

	@Override

	public void setRequestFactory(ClientHttpRequestFactory requestFactory) {

		super.setRequestFactory(requestFactory);

		this.interceptingRequestFactory = null;

	}

	@Override

	public ClientHttpRequestFactory getRequestFactory() {

		List<ClientHttpRequestInterceptor> 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();

		}

	}

}

这个类的关键在于重写了父类的getRequestFacotry(), 当前做过SpringCloud Ribbon远程调用，会对这个方法格外熟悉，Spring会判断拦截器属性_interceptors是否有值，如果有值则会继续判断，然后返回InterceptionClientHttpRequestFactory, 如果拦截器属性没有值，则调用父类HttpAccessor#getRequestFactory().

RestTemplate#doExecute()

通过分析抽象父类InterceptingHttpAccessor和HttpAccessor，我们得出结果，如果没有拦截器，只是普通的RESTFUL调用，那么最终是调用SimpleClientHttpRequestFactory#createRequest().

@Override

public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {

    #再回头看看Spring对RestTemplate定义里提到的，RestTemplate的核心就是使用

    #HttpURLConnection和HTTP服务器进行通信。

    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);

    }

}

protected HttpURLConnection openConnection(URL url, @Nullable Proxy proxy) throws IOException {

	URLConnection urlConnection = (proxy != null ? url.openConnection(proxy) : url.openConnection());

    if (!HttpURLConnection.class.isInstance(urlConnection)) {

        throw new IllegalStateException("HttpURLConnection required for [" + url + "] but got: " + urlConnection);

    }

    return (HttpURLConnection) urlConnection;

}

protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {

    if (this.connectTimeout >= 0) {

        connection.setConnectTimeout(this.connectTimeout);

    }

    if (this.readTimeout >= 0) {

        connection.setReadTimeout(this.readTimeout);

    }

    connection.setDoInput(true);

    if ("GET".equals(httpMethod)) {

        connection.setInstanceFollowRedirects(true);

    }

    else {

        connection.setInstanceFollowRedirects(false);

    }

    if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) ||

        "PATCH".equals(httpMethod) || "DELETE".equals(httpMethod)) {

        connection.setDoOutput(true);

    }

    else {

        connection.setDoOutput(false);

    }

	connection.setRequestMethod(httpMethod);

}

从这里代码片段分析，我们可以回到上面提的问题, 在doExecute里createRequest()最终创建的实现类是SimpleBufferingClientHttpRequest。

SimpleBufferingClientHttpRequest类结构图

SimpleStreamingClientHttpRequest类结构图

requestCallback.doWithRequest()

根据自己需要实现接口RequestCallback#doWithRequest()。

request.execute()

这里也就是调用SimplezBufferingClientHttpRequest#execute()。通过分析SimplezBufferingClientHttpRequest代码，我们知道execute()定义在抽象父类AbstractClientHttpRequest里

#AbstractClientHttpRequest#execute()

@Override

public final ClientHttpResponse execute() throws IOException {

    assertNotExecuted();

    ClientHttpResponse result = executeInternal(this.headers);

    this.executed = true;

    return result;

}

分析这个类可以看出，很经典的一个设计，父类定义行为，具体实现交给子类，这里可以看出execute里继续调用executeInternal，这是一个抽象方法，交给子类实现。

AbstractBufferingClientHttpRequest#executeInternal

@Override

protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException {

    byte[] bytes = this.bufferedOutput.toByteArray();

    if (headers.getContentLength() < 0) {

        headers.setContentLength(bytes.length);

    }

    ClientHttpResponse result = executeInternal(headers, bytes);

    this.bufferedOutput = new ByteArrayOutputStream(0);

    return result;

}

SimpleBufferingClientHttpRequest#executeInternal

@Override

protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {

    addHeaders(this.connection, headers);

    // JDK <1.8 doesn't support getOutputStream with HTTP DELETE

    if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {

        this.connection.setDoOutput(false);

    }

    if (this.connection.getDoOutput() && this.outputStreaming) {

        this.connection.setFixedLengthStreamingMode(bufferedOutput.length);

    }

    this.connection.connect();

    if (this.connection.getDoOutput()) {

        FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());

    }

    else {

        // Immediately trigger the request in a no-output scenario as well

        this.connection.getResponseCode();

    }

    return new SimpleClientHttpResponse(this.connection);

}

至此，我们就拿到请求的返回结果Response了，封装SimpleClientHttpResponse并返回。似乎这几个类分析下来觉得他的调用流程并没有想象的那么复杂，整个设计还是很规范。

handleResponse

RestTemplate#handleResponse

protected void handleResponse(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {

    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);

    }

}

getErrorHandler获取了一个错误处理器，如果Response的状态码是错误的，那么就调用handleError处理错误并抛出异常。

responseExtractor.extractData

ResponseExtractor是一个函数式接口，主要实现类有三个。

HeadersExtractor - RestTemplat的内部类。
ResponseEntityResponseExtractor - RestTemplate内部类。
HttpMessageConverterExtractor。

前两个都是内部类，我们主要看一下HttpMessageConverterExtractor。

@Override

@SuppressWarnings({"unchecked", "rawtypes", "resource"})

public T extractData(ClientHttpResponse response) throws IOException {

    MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);

    if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {

        return null;

    }

    MediaType contentType = getContentType(responseWrapper);

    try {

        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {

            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);

                }

            }

        }

    }

    catch (IOException | HttpMessageNotReadableException ex) {

        throw new RestClientException("Error while extracting response for type [" +

                                      this.responseType + "] and content type [" + contentType + "]", ex);

    }

    throw new RestClientException("Could not extract response: no suitable HttpMessageConverter found " +

                                  "for response type [" + this.responseType + "] and content type [" + contentType + "]");

}

可以看到，extractData先将response交给responseWrapper，如果responseWrapper有消息体且非空，则进行返回消息的读取操作。
消息的读取需要借助HttpMessageConverter接口，HttpMessageConverter具有多种实现类，以完成不同格式消息的读取，相当于消息解码器或转换头。

总结

RestTemplate提供了多种便捷访问HTTP服务的方法，提高了客户端的编码效率。底层通过使用java.net包创建HTTP请求。主要使用ClientHttpRequestFactory指定不同的HTTP请求方式。

巴特西