共计 20435 个字符，预计需要花费 52 分钟才能阅读完成。
每篇一句
做事的人和做梦的人最大的区别就是行动力
前言
本文为深入了解 Spring 提供的 Rest 调用客户端 RestTemplate 开山，对它相关的一些组件做讲解。
Tips：请注意区分
RestTemplate和RedisTemplate哦~
ClientHttpRequestFactory
它是个函数式接口，用于根据 URI 和HttpMethod创建出一个 ClientHttpRequest 来发送请求~
ClientHttpRequest它代表请求的客户端，该接口继承自HttpRequest、HttpOutputMessage，只有一个ClientHttpResponse execute() throws IOException方法。其中Netty、HttpComponents、OkHttp3，HttpUrlConnection对它都有实现~
// @since 3.0 RestTemplate 这个体系都是 3.0 后才有的
@FunctionalInterface
public interface ClientHttpRequestFactory {// 返回一个 ClientHttpRequest，这样调用其 execute()方法就可以发送 rest 请求了~
ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException;
}它的继承树如下：
可以直观的看到，我们可以使用 Apache 的HttpClient、OkHttp3、Netty4都可，但这些都需要额外导包，默认情况下 Spring 使用的是java.net.HttpURLConnection。
HttpClient 最新版本：4.5.10
OkHttp 最新版本：4.1.1（虽然版本号是 4，但是 GAV 还是 3 哦：com.squareup.okhttp3）
Netty 最新版本：4.1.39.Final（它的 5 版本可以宣告已死）
Spring4.0是新增了一个对异步支持的AsyncClientHttpRequestFactory（Spring5.0 后标记为已废弃）：
// 在 Spring5.0 后被标记为过时了，被 org.springframework.http.client.reactive.ClientHttpConnector 所取代（但还是可用的嘛）@Deprecated
public interface AsyncClientHttpRequestFactory {// AsyncClientHttpRequest#executeAsync()返回的是 ListenableFuture<ClientHttpResponse>
// 可见它的异步是通过 ListenableFuture 实现的
AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod) throws IOException;
}使用工厂创建ClientHttpRequest ，然后我们发请求就不用关心具体 httpClient 内部的细节了（可插拔使用二方库、三方库）
SimpleClientHttpRequestFactory
它是 Spring 内置默认的实现，使用的是 JDK 内置的 java.net.URLConnection 作为 client 客户端。
public class SimpleClientHttpRequestFactory implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory {
private static final int DEFAULT_CHUNK_SIZE = 4096;
@Nullable
private Proxy proxy; //java.net.Proxy
private boolean bufferRequestBody = true; // 默认会缓冲 body
// URLConnection's connect timeout (in milliseconds).
// 若值设置为 0，表示永不超时 @see URLConnection#setConnectTimeout(int)
private int connectTimeout = -1;
// URLConnection#setReadTimeout(int)
// 超时规则同上
private int readTimeout = -1;
//Set if the underlying URLConnection can be set to 'output streaming' mode.
private boolean outputStreaming = true;
// 异步的时候需要
@Nullable
private AsyncListenableTaskExecutor taskExecutor;
... // 省略所有的 set 方法
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
// 打开一个 HttpURLConnection
HttpURLConnection connection = openConnection(uri.toURL(), this.proxy);
// 设置超时时间、请求方法等一些参数到 connection
prepareConnection(connection, httpMethod.name());
//SimpleBufferingClientHttpRequest 的 excute 方法最终使用的是 connection.connect();
// 然后从 connection 中得到响应码、响应体~~~
if (this.bufferRequestBody) {return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming);
} else {return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming);
}
}
// createAsyncRequest()方法略，无非就是在线程池里异步完成请求
...
}需要注意的是：JDK <1.8 doesn't support getOutputStream with HTTP DELETE，也就是说如果 JDK 的版本低于 1.8 的话，那么 Delete 请求是不支持 body 体的。
Demo Show：
public static void main(String[] args) throws IOException {SimpleClientHttpRequestFactory clientFactory = new SimpleClientHttpRequestFactory();
// ConnectTimeout 只有在网络正常的情况下才有效，因此两个一般都设置
clientFactory.setConnectTimeout(5000); // 建立连接的超时时间 5 秒
clientFactory.setReadTimeout(5000); // 传递数据的超时时间（在网络抖动的情况下，这个参数很有用）ClientHttpRequest client = clientFactory.createRequest(URI.create("https://www.baidu.com"), HttpMethod.GET);
// 发送请求
ClientHttpResponse response = client.execute();
System.out.println(response.getStatusCode()); //200 OK
System.out.println(response.getStatusText()); // OK
System.out.println(response.getHeaders()); //
// 返回内容 是个 InputStream
byte[] bytes = FileCopyUtils.copyToByteArray(response.getBody());
System.out.println(new String(bytes, StandardCharsets.UTF_8)); // 百度首页内容的 html
}关于 HttpURLConnection 的 API 使用，需注意如下几点：
-
HttpURLConnection对象不能直接构造，需要通过 URL 类中的openConnection()方法来获得 -
HttpURLConnection的 connect()函数，实际上只是建立了一个与服务器的 TCP 连接，并没有实际发送 HTTP 请求。HTTP 请求实际上直到我们获取服务器响应数据（如调用 getInputStream()、getResponseCode()等方法）时才正式发送出去1. 配置信息都需要在 connect()方法执行之前完成 -
HttpURLConnection是基于 HTTP 协议的，其底层通过 socket 通信实现。如果不设置超时（timeout），在网络异常的情况下，可能会导致程序僵死而不继续往下执行。== 请务必 100% 设置 == - HTTP 正文的内容是通过 OutputStream 流写入的，向流中写入的数据不会立即发送到网络，而是存在于内存缓冲区中，待流关闭时，根据写入的内容生成 HTTP 正文
- 调用 getInputStream()方法时，返回一个 输入流，用于从中读取服务器对于 HTTP 请求的返回信息。
-
HttpURLConnection.connect()不是必须的。当我们需要返回值时，比如我们使用 HttpURLConnection.getInputStream()方法的时候它就会自动发送请求了，所以完全没有必要调用 connect()方法了（没必要先建立 Tcp 嘛~）。
使用哪一个底层 http 库？
我们知道 HttpURLConnection 它在功能上是有些不足的（简单的提交参数可以满足）。绝大部分情况下 Web 站点的网页可能没这么简单，这些页面并不是通过一个简单的 URL 就可访问的，可能需要用户登录而且具有相应的权限才可访问该页面。在这种情况下，就需要涉及 Session、Cookie 的处理了，如果打算使用 HttpURLConnection 来处理这些细节，当然也是可能实现的，只是处理起来难度就大了。
这个时候，Apache 开源组织提供了一个 HttpClient 项目，可以用于发送 HTTP 请求，接收 HTTP 响应（包含 HttpGet、HttpPost… 等各种发送请求的对象）。
它不会缓存服务器的响应，不能执行 HTML 页面中嵌入的 Javascript 代码；也不会对页面内容进行任何解析、处理
因此，下面我就让 Spring 使用 HttpClient 为示例演示使用三方库：
1、导包
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.10</version>
</dependency>Tips：Requires Apache HttpComponents
4.3or higher, as of Spring 4.0.
2、案例使用
案例内容 仅仅只需 把上例第一句话换成使用 HttpComponentsClientHttpRequestFactory 它的实例，其余都不用变化即可成功看到效果。可以看看这个类它具体做了什么
// @since 3.1 3.1 后出现的。public class HttpComponentsClientHttpRequestFactory implements ClientHttpRequestFactory, DisposableBean {
private HttpClient httpClient;
@Nullable
private RequestConfig requestConfig; // 这个配置就是可以配置超时等等乱七八糟 client 属性的类
private boolean bufferRequestBody = true;
//========= 下面是构造函数们 =========
public HttpComponentsClientHttpRequestFactory() {// HttpClientBuilder.create().useSystemProperties().build();
// 所有若是这里，配置超时时间可以这么来设置也可：// System.setProperty(”sun.net.client.defaultConnectTimeout”,“5000″);
this.httpClient = HttpClients.createSystem();}
// 当然可以把你配置好了的 Client 扔进来
public HttpComponentsClientHttpRequestFactory(HttpClient httpClient) {this.httpClient = httpClient;}
... // 省略设置超时时间。。。等等属性的一些 get/set
// 超时信息啥的都是保存在 `RequestConfig` 里的
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {HttpClient client = getHttpClient(); // 拿到你指定的 client）=（或者系统缺省的）// switch 语句逻辑：HttpMethod == GET --> HttpGet HEAD --> HttpHead ...
HttpUriRequest httpRequest = createHttpUriRequest(httpMethod, uri);
postProcessHttpRequest(httpRequest);
...
}
}实际使用的是 HttpClient 完成的请求。另外 OkHttp3ClientHttpRequestFactory 使用的是 okhttp3.OkHttpClient 发送请求；Netty4ClientHttpRequestFactory使用的是io.netty.channel.EventLoopGroup。此处就不一一例举了
Spring5.0 以后，
Netty4ClientHttpRequestFactory过期了，建议使用org.springframework.http.client.reactive.ReactorClientHttpConnector代替~
关于 HttpURLConnection、HttpClient、OkHttpClient 的简单比较：
-
HttpURLConnection：- 优点：JDK 内置支持，java 的标准类 - 缺点：API 不够友好，什么都没封装，用起来太原始，不方便（这其实有时候也算优点，原始就证明好控~） -
HttpClient：- 优点：功能强大，API 友好，使用率够高，几乎成为了实际意义上的标准（相当于对 `HttpURLConnection` 的封装）- 缺点：性能稍低（比 `HttpURLConnection` 低，但 4.3 后使用连接池进行了改善），API 较臃肿，其实 Android 已经弃用了它~ -
OkHttpClient：新一代的 Http 访问客户端- 优点：一个专注于 ** 性能和易用性 ** 的 HTTP 客户端（节约宽带，Android 推荐使用），它设计的首要目标就是高效。提供了最新的 HTTP 协议版本 HTTP/2 和 SPDY 的支持。如果 HTTP/2 和 SPDY 不可用，OkHttp 会使用连接池来复用连接以提高效率 - 暂无。
关于Apache HttpClient，Android5.0 之后已经废弃使用它了（API 太多，太重），推荐使用更轻量的HttpUrlConnection。（Java 开发还是推荐用HttpClient）
OkHttp优点较多：支持 SPDY，可以合并多个到同一个主机的请求；OkHttp 实现的诸多技术如：连接池，gziping，缓存等；OkHttp 处理了很多网络疑难杂症：会从很多常用的连接问题中自动恢复。如果您的服务器配置了多个 IP 地址，当第一个 IP 连接失败的时候，OkHttp 会自动尝试下一个 IP；OkHttp 是一个 Java 的 HTTP+SPDY 客户端开发包，同时也支持 Android。默认情况下，OKHttp 会自动处理常见的网络问题，像二次连接、SSL 的握手问题 。支持文件上传、下载、cookie、session、https 证书等几乎所有功能。 支持取消某个请求
综上所述，不管是 Java 还是 Android，我推荐的自然都是OkHttp（OkHttp 使用 Okio 进行数据传输。都是 Square 公司自家的，Square 公司还出了一个 Retrofit 库配合 OkHttp 战斗力翻倍）~~~
池化技术一般用于长连接，那么像 Http 这种适合连接池吗？
HttpClient 4.3 以后中使用了PoolingHttpClientConnectionManager连接池来管理持有连接，同一条 TCP 链路上，连接是可以复用的。HttpClient 通过连接池的方式进行连接持久化（所以它这个连接池其实是 tcp 的连接池。它里面有一个很重要的概念：Route的概念，代表一条线路。比如 baidu.com 是一个 route，163.com 是一个 route…）。
连接池：可能是 http 请求，也可能是 https 请求
加入池话技术，就不用每次发起请求都新建一个连接（每次连接握手三次，效率太低）
AbstractClientHttpRequestFactoryWrapper
对其它 ClientHttpRequestFactory 的一个包装抽象类，它有如下两个子类实现
InterceptingClientHttpRequestFactory（重要）
Interceptor拦截的概念，还是蛮重要的。它持有的 ClientHttpRequestInterceptor 对于我们若想要拦截发出去的请求非常之重要（比如全链路压测中，可以使用它设置 token 之类的~）
// @since 3.1
public class InterceptingClientHttpRequestFactory extends AbstractClientHttpRequestFactoryWrapper {
// 持有所有的请求拦截器
private final List<ClientHttpRequestInterceptor> interceptors;
public InterceptingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory, @Nullable List<ClientHttpRequestInterceptor> interceptors) {super(requestFactory);
// 拦截器只允许通过构造函数设置进来，并且并没有提供 get 方法方法~
this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
}
// 此处返回的是一个 InterceptingClientHttpRequest，显然它肯定是个 ClientHttpRequest 嘛~
@Override
protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory) {return new InterceptingClientHttpRequest(requestFactory, this.interceptors, uri, httpMethod);
}
}InterceptingClientHttpRequest的 execute() 方法的特点是：若存在拦截器，交给给拦截器去执行发送请求return nextInterceptor.intercept(request, body, this)，否则就自己上。
ClientHttpRequestInterceptor
关于请求拦截器，Spring MVC 内置了两个最基础的实现
==BasicAuthorizationInterceptor==：
// @since 4.3.1 但在 Spring5.1.1 后推荐使用 BasicAuthenticationInterceptor
@Deprecated
public class BasicAuthorizationInterceptor implements ClientHttpRequestInterceptor {
private final String username;
private final String password;
// 注意：username 不允许包含: 这个字符，但是密码是允许的
public BasicAuthorizationInterceptor(@Nullable String username, @Nullable String password) {Assert.doesNotContain(username, ":", "Username must not contain a colon");
this.username = (username != null ? username : "");
this.password = (password != null ? password : "");
}
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
// 用户名密码连接起来后，用 Base64 对字节码进行编码~
String token = Base64Utils.encodeToString((this.username + ":" + this.password).getBytes(StandardCharsets.UTF_8));
// 放进请求头：key 为 `Authorization` 然后执行请求的发送
request.getHeaders().add("Authorization", "Basic" + token);
return execution.execute(request, body);
}
}这个拦截器木有对 body 有任何改动，只是把用户名、密码帮你放进了请求头上。
需要注意的是：若你的 header 里已经存在了
Authorization这个 key，这里也不会覆盖的，这会添加哦。但并不建议你有覆盖现象~
==BasicAuthenticationInterceptor==：
它是用来代替上类的。它使用标准的授权头来处理，参考HttpHeaders#setBasicAuth、HttpHeaders#AUTHORIZATION
public class BasicAuthenticationInterceptor implements ClientHttpRequestInterceptor {
private final String username;
private final String password;
// 编码，一般不用指定
@Nullable
private final Charset charset;
... // 构造函数略
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {HttpHeaders headers = request.getHeaders();
// 只有当请求里不包含 `Authorization` 这个 key 的时候，此处才会设置授权头哦
if (!headers.containsKey(HttpHeaders.AUTHORIZATION)) {
// 这个方法是 @since 5.1 之后才提供的~~~~~
// 若不包含此 key，就设置标准的授权头（根据用户名、密码）它内部也有这如下三步：// String credentialsString = username + ":" + password;
// byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(charset));
// String encodedCredentials = new String(encodedBytes, charset);
// 注意：它内部最终还是调用 set(AUTHORIZATION, "Basic" + encodedCredentials); 这个方法的
headers.setBasicAuth(this.username, this.password, this.charset);
}
return execution.execute(request, body);
}
}说明：这两个请求拦截器虽是 Spring 提供，但默认都是没有被 ” 装配 ” 的，所亲需要，请手动装配~
BufferingClientHttpRequestFactory
包装其它 ClientHttpRequestFactory，使得具有缓存的能力。若开启缓存功能（有开关可控），会使用BufferingClientHttpRequestWrapper 包装原来的 ClientHttpRequest。这样发送请求后得到的是BufferingClientHttpResponseWrapper 响应。
ResponseErrorHandler
用于确定特定响应是否有错误的策略接口。
// @since 3.0
public interface ResponseErrorHandler {
// response 里是否有错
boolean hasError(ClientHttpResponse response) throws IOException;
// 只有 hasError = true 时才会调用此方法
void handleError(ClientHttpResponse response) throws IOException;
// @since 5.0
default void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {handleError(response);
}
}继承树如下：
DefaultResponseErrorHandler
Spring对此策略接口的默认实现，RestTemplate默认使用的错误处理器就是它。
// @since 3.0
public class DefaultResponseErrorHandler implements ResponseErrorHandler {
// 是否有错误是根据响应码来的，所以请严格遵守响应码的规范啊
// 简单的说 4xx 和 5xx 都会被认为有错，否则是无错的 参考：HttpStatus.Series
@Override
public boolean hasError(ClientHttpResponse response) throws IOException {int rawStatusCode = response.getRawStatusCode();
HttpStatus statusCode = HttpStatus.resolve(rawStatusCode);
return (statusCode != null ? hasError(statusCode) : hasError(rawStatusCode));
}
...
// 处理错误
@Override
public void handleError(ClientHttpResponse response) throws IOException {HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
if (statusCode == null) {throw new UnknownHttpStatusCodeException(response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), getResponseBody(response), getCharset(response));
}
handleError(response, statusCode);
}
// protected 方法，子类对它有复写
protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {String statusText = response.getStatusText();
HttpHeaders headers = response.getHeaders();
byte[] body = getResponseBody(response); // 拿到 body，把 InputStream 转换为字节数组
Charset charset = getCharset(response); // 注意这里的编码，是从返回的 contentType 里拿的~~~
// 分别针对于客户端错误、服务端错误 包装为 HttpClientErrorException 和 HttpServerErrorException 进行抛出
// 异常内包含有状态码、状态 text、头、body、编码等等信息~~~~
switch (statusCode.series()) {
case CLIENT_ERROR:
throw HttpClientErrorException.create(statusCode, statusText, headers, body, charset);
case SERVER_ERROR:
throw HttpServerErrorException.create(statusCode, statusText, headers, body, charset);
default:
throw new UnknownHttpStatusCodeException(statusCode.value(), statusText, headers, body, charset);
}
}
...
}到这里就可以给大家解释一下，为何经常能看到客户端错误，然后还有状态码 + 一串信息了，就是因为这两个异常。
HttpClientErrorException：
public class HttpClientErrorException extends HttpStatusCodeException {
...
public static HttpClientErrorException create(HttpStatus statusCode, String statusText, HttpHeaders headers, byte[] body, @Nullable Charset charset) {switch (statusCode) {
case BAD_REQUEST:
return new HttpClientErrorException.BadRequest(statusText, headers, body, charset);
case UNAUTHORIZED:
return new HttpClientErrorException.Unauthorized(statusText, headers, body, charset);
case FORBIDDEN:
return new HttpClientErrorException.Forbidden(statusText, headers, body, charset);
case NOT_FOUND:
return new HttpClientErrorException.NotFound(statusText, headers, body, charset);
case METHOD_NOT_ALLOWED:
return new HttpClientErrorException.MethodNotAllowed(statusText, headers, body, charset);
case NOT_ACCEPTABLE:
return new HttpClientErrorException.NotAcceptable(statusText, headers, body, charset);
case CONFLICT:
return new HttpClientErrorException.Conflict(statusText, headers, body, charset);
case GONE:
return new HttpClientErrorException.Gone(statusText, headers, body, charset);
case UNSUPPORTED_MEDIA_TYPE:
return new HttpClientErrorException.UnsupportedMediaType(statusText, headers, body, charset);
case TOO_MANY_REQUESTS:
return new HttpClientErrorException.TooManyRequests(statusText, headers, body, charset);
case UNPROCESSABLE_ENTITY:
return new HttpClientErrorException.UnprocessableEntity(statusText, headers, body, charset);
default:
return new HttpClientErrorException(statusCode, statusText, headers, body, charset);
}
}
...
}它针对不同的状态码HttpStatus，创建了不同的类型进行返回，方便使用者控制，这在监控上还是蛮有意义的
BadRequest、Unauthorized、Forbidden… 等等都是
HttpClientErrorException的子类
HttpServerErrorException代码类似，略~
ExtractingResponseErrorHandler
继承自 DefaultResponseErrorHandler。在RESTful 大行其道的今天，Spring5.0开始提供了此类。它将 http 错误响应利用 HttpMessageConverter 转换为对应的RestClientException
// @since 5.0 它出现得还是很晚的。继承自 DefaultResponseErrorHandler
// 若你的 RestTemplate 想使用它，请调用 RestTemplate#setErrorHandler(ResponseErrorHandler)设置即可
public class ExtractingResponseErrorHandler extends DefaultResponseErrorHandler {private List<HttpMessageConverter<?>> messageConverters = Collections.emptyList();
// 对响应码做缓存
private final Map<HttpStatus, Class<? extends RestClientException>> statusMapping = new LinkedHashMap<>();
private final Map<HttpStatus.Series, Class<? extends RestClientException>> seriesMapping = new LinkedHashMap<>();
// 构造函数、set 方法给上面两个 Map 赋值。因为我们可以自己控制哪些状态码应该报错，哪些不应该了~
// 以及可以自定义：那个状态码抛我们自定义的异常，哪一系列状态码抛我们自定义的异常，这个十分的便于我们做监控
... // 省略构造函数和 set 方法。。。// 增加缓存功能~~~ 否则在交给父类
@Override
protected boolean hasError(HttpStatus statusCode) {if (this.statusMapping.containsKey(statusCode)) {return this.statusMapping.get(statusCode) != null;
} else if (this.seriesMapping.containsKey(statusCode.series())) {return this.seriesMapping.get(statusCode.series()) != null;
} else {return super.hasError(statusCode);
}
}
// 这个它做的事：extract：提取
@Override
public void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {if (this.statusMapping.containsKey(statusCode)) {extract(this.statusMapping.get(statusCode), response);
} else if (this.seriesMapping.containsKey(statusCode.series())) {extract(this.seriesMapping.get(statusCode.series()), response);
} else {super.handleError(response, statusCode);
}
}
private void extract(@Nullable Class<? extends RestClientException> exceptionClass, ClientHttpResponse response) throws IOException {if (exceptionClass == null) {return;}
// 这里使用到了 ResponseExtractor 返回值提取器, 从返回值里提取内容(本文是提取异常)
HttpMessageConverterExtractor<? extends RestClientException> extractor =
new HttpMessageConverterExtractor<>(exceptionClass, this.messageConverters);
RestClientException exception = extractor.extractData(response);
if (exception != null) { // 若提取到了异常信息，抛出即可
throw exception;
}
}
}若你想定制请求异常的处理逻辑，你也是可以自定义这个接口的实现的，当然还是建议你通过继承 DefaultResponseErrorHandler 来扩展~
ResponseExtractor
响应提取器：从 Response 中提取数据。RestTemplate请求完成后，都是通过它来从 ClientHttpResponse 提取出指定内容（比如请求头、请求 Body 体等）~
它的直接实现似乎只有 HttpMessageConverterExtractor，当然它也是最为重要的一个实现，和HttpMessageConverter 相关。
在解释它之前，先看看这个：MessageBodyClientHttpResponseWrapper，它的特点：它不仅可以通过实际读取输入流来检查响应是否有消息体，还可以检查其长度是否为 0（即空）
// @since 4.1.5 它是一个访问权限是 default 的类，是对其它 ClientHttpResponse 的一个包装
class MessageBodyClientHttpResponseWrapper implements ClientHttpResponse {
private final ClientHttpResponse response;
// java.io.PushbackInputStream
@Nullable
private PushbackInputStream pushbackInputStream;
// 判断相应里是否有 body 体
// 若响应码是 1xx 或者是 204；或者 getHeaders().getContentLength() == 0 那就返回 false 否则返回 true
public boolean hasMessageBody() throws IOException {HttpStatus status = HttpStatus.resolve(getRawStatusCode());
if (status != null && (status.is1xxInformational() || status == HttpStatus.NO_CONTENT || status == HttpStatus.NOT_MODIFIED)) {return false;}
if (getHeaders().getContentLength() == 0) {return false;}
return true;
}
// 上面是完全格局状态码（ContentLength）来判断是否有 body 体的~~~ 这里会根据流来判断
// 如果 response.getBody() == null, 返回 true
// 若流里有内容，最终就用 new PushbackInputStream(body)包装起来~~~
public boolean hasEmptyMessageBody() throws IOException {...}
... // 其余接口方法都委托~
@Override
public InputStream getBody() throws IOException {return (this.pushbackInputStream != null ? this.pushbackInputStream : this.response.getBody());
}
}它的作用就是包装后，提供两个方法 hasMessageBody、hasEmptyMessageBody 方便了对 body 体内容进行判断
// @since 3.0 泛型 T：the data type
public class HttpMessageConverterExtractor<T> implements ResponseExtractor<T> {
// java.lang.reflect.Type
private final Type responseType;
// 这个泛型也是 T，表示数据的 Class 嘛~
// 该 calss 有可能就是上面的 responseType
@Nullable
private final Class<T> responseClass;
// 重要：用于消息解析的转换器
private final List<HttpMessageConverter<?>> messageConverters;
... // 省略构造函数
// 从 ClientHttpResponse 里提取值
@Override
@SuppressWarnings({"unchecked", "rawtypes", "resource"})
public T extractData(ClientHttpResponse response) throws IOException {MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);
// 若没有消息体（状态码不对 或者 消息体为空都被认为是木有）if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {return null;}
// content-type 若响应头 header 里没有指定，那默认是它 MediaType.APPLICATION_OCTET_STREAM
MediaType contentType = getContentType(responseWrapper);
// 遍历所有的 messageConverters，根据 contentType 来选则一个消息转换器
// 最终 return messageConverter.read((Class) this.responseClass, responseWrapper)
...
}
}它的处理逻辑理解起来非常简单：利用 contentType 找到一个消息转换器，最终 HttpMessageConverter.read() 把消息读出来转换成 Java 对象。
它还有两个内部类的实现如下（都是 RestTemplate 的私有内部类）：
RestTemplate：// 提取为 `ResponseEntity` 最终委托给 HttpMessageConverterExtractor 完成的
private class ResponseEntityResponseExtractor<T> implements ResponseExtractor<ResponseEntity<T>> {
@Nullable
private final HttpMessageConverterExtractor<T> delegate;
public ResponseEntityResponseExtractor(@Nullable Type responseType) {
// 显然：只有请求的返回值不为 null 才有意义~
if (responseType != null && Void.class != responseType) {this.delegate = new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
} else {this.delegate = null;}
}
// 数据提取。都是交给 `delegate.extractData(response)` 做了，然后 new 一个 ResponseEntity 出来包装进去
// 若木有返回值（delegate=null），那就是一个 `ResponseEntity` 实例，body 为 null
@Override
public ResponseEntity<T> extractData(ClientHttpResponse response) throws IOException {if (this.delegate != null) {T body = this.delegate.extractData(response);
return ResponseEntity.status(response.getRawStatusCode()).headers(response.getHeaders()).body(body);
}
else {return ResponseEntity.status(response.getRawStatusCode()).headers(response.getHeaders()).build();}
}
}
// 提取请求头
private static class HeadersExtractor implements ResponseExtractor<HttpHeaders> {
@Override
public HttpHeaders extractData(ClientHttpResponse response) {return response.getHeaders();
}
}UriTemplateHandler
这个组件它用于 定义用变量扩展 uri 模板的方法。
// @since 4.2 出现较晚
// @see RestTemplate#setUriTemplateHandler(UriTemplateHandler)
public interface UriTemplateHandler {URI expand(String uriTemplate, Map<String, ?> uriVariables);
URI expand(String uriTemplate, Object... uriVariables);
}关于 URI 的处理，最终都是委托给 UriComponentsBuilder 来完成。若对这块还存在一定疑问的，强烈强烈强烈 参考这里
推荐阅读
RestTemplate 的使用和原理你都烂熟于胸了吗？【享学 Spring MVC】
总结
本文介绍的组件是去理解 RestTemplate 必备的组件们，属于开山篇。因为 RestTemplate 使用频繁，并且经常需要调优，因此我寄希望大家也能对它做较为深入的了解，这也是我写本系列的目的，共勉。
== 若对 Spring、SpringBoot、MyBatis 等源码分析感兴趣，可加我 wx：fsx641385712，手动邀请你入群一起飞 ==
== 若对 Spring、SpringBoot、MyBatis 等源码分析感兴趣，可加我 wx：fsx641385712，手动邀请你入群一起飞 ==
