引
年后就是跳槽的高峰期，年前参加了几场面试，基本上都会问对于常用的第三方框架的了解，由于之前主要从事系统开发的工作，所以对于常用的网络框架不是很了解。借此机会学习总结一下OkHttp网络请求框架。
本文从官方提供的示例入手，尝试分析学习OkHttp框架（3.9.1版本）的源码，
OkHttp简介
An HTTP & HTTP/2 client for Android and Java applications
根据官网介绍，OkHttp是一个用于java和Android的HTTP&HTTP/2请求的客户端。
而在Android系统的原生库类中，有两个用于http请求的库类，在Android2.2之前，推荐使用HttpClient，而在Android2.2之后推荐使用HttpURLConnection。
优点
相比于官方的原生网络请求库，OkHttp有以下优点：
- 支持HTTP/2, HTTP/2通过使用多路复用技术在一个单独的TCP连接上支持并发,通过在一个连接上一次性发送多个请求来发送或接收数据
- 通过连接池复用技术(Http)减少延时
- 支持Gzip降低下载大小
- 支持响应缓存避免了重复请求的网络
get流程
官方示例
//1.创建OkHttpClient
OkHttpClient client = new OkHttpClient();
//2.创建Request，并填入url信息
String run(String url) throws IOException {
Request request = new Request.Builder()
.url(url)
.build();
//3.通过OkHttpClient的newcall进行同步请求
Response response = client.newCall(request).execute();
//4.返回请求结果
return response.body().string();
}
流程分析
1.创建OkHttpClient
构建了一个OkHttpClient
//1.创建OkHttpClient
OkHttpClient client = new OkHttpClient();
public OkHttpClient() {
//通过默认builder构建一个新的OkHttpClient
this(new Builder());
}
//初始化builder用于配置各种参数
public Builder() {
//异步请求的执行策略调度器
dispatcher = new Dispatcher();
//默认的协议列表
protocols = DEFAULT_PROTOCOLS;
//默认的连接规范
connectionSpecs = DEFAULT_CONNECTION_SPECS;
//指标事件的监听器
eventListenerFactory = EventListener.factory(EventListener.NONE);
//默认的代理选择器
proxySelector = ProxySelector.getDefault();
//默认不管理cookie
cookieJar = CookieJar.NO_COOKIES;
//默认的socket工厂
socketFactory = SocketFactory.getDefault();
//默认的主机名验证
hostnameVerifier = OkHostnameVerifier.INSTANCE;
//固定证书，默认不开启
certificatePinner = CertificatePinner.DEFAULT;
//响应服务器身份验证质询，默认不进行响应
proxyAuthenticator = Authenticator.NONE;
authenticator = Authenticator.NONE;
//初始化连接池
connectionPool = new ConnectionPool();
//默认DNS
dns = Dns.SYSTEM;
followSslRedirects = true;
followRedirects = true;
retryOnConnectionFailure = true;
//超时时间
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
2.创建Request，并填入url信息
通过构造器模式创建Request对象
//2.创建Request，并填入url信息
String run(String url) throws IOException {
Request request = new Request.Builder()
.url(url)
.build();
首先通过Builder()方法构建一个Builder对象
//Builder
public Builder() {
//默认方法为get
this.method = "GET";
//初始化一个空的请求头
this.headers = new Headers.Builder();
}
然后通过url(url)方法对url进行了设置
public Builder url(String url) {
//检测传入的url是否为空
if (url == null) throw new NullPointerException("url == null");
//将socket url替换为Http url
if (url.regionMatches(true, 0, "ws:", 0, 3)) {
url = "http:" + url.substring(3);
} else if (url.regionMatches(true, 0, "wss:", 0, 4)) {
url = "https:" + url.substring(4);
}
//根据传入的url生成一个HttpUrl
HttpUrl parsed = HttpUrl.parse(url);
//如果为空则说明传入的不是一个格式正确的http/https url
if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
//将http传入url,返回Builder
return url(parsed);
}
//将传入的HttpUrl赋值为成员变量后返回Builder
public Builder url(HttpUrl url) {
if (url == null) throw new NullPointerException("url == null");
this.url = url;
return this;
}
最后调用build()方法完成Request的创建
public Request build() {
//检测url是否为空，若为空则抛出异常
if (url == null) throw new IllegalStateException("url == null");
return new Request(this);
}
//Request
Request(Builder builder) {
//请求地址
this.url = builder.url;
//请求方法
this.method = builder.method;
//请求头
this.headers = builder.headers.build();
//请求体
this.body = builder.body;
//tag标记，可用来统一删除
this.tag = builder.tag != null ? builder.tag : this;
}
可见url是创建Request时不可缺少的一个部分，一个Request中必须填入其url
而Request中包换五个部分，除tag外分别与Http请求中的请求地址、请求方法、请求头和请求体四部分别对应。至于Http请求所需的请求协议，Okhttp是通过使用请求协议的协商升级来进行确定的。
3.通过OkHttpClient的newcall进行同步请求
第三步是整个网络请求中的重中之重，它通过对我们的Request进行解析生成相应的call来获取我们所需的Response。
Response response = client.newCall(request).execute();
首先通过newCall(request)方法根据请求创建了一个call
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
//传入参数生成Realcall
RealCall call = new RealCall(client, originalRequest, forWebSocket);
//为生成call创建一个eventListener实例，用于监听请求的各个阶段
call.eventListener = client.eventListenerFactory().create(call);
return call;
}
//三个参数分别对应之前创建的OkHttpClient，传入的Request，已经是否为WebSocket此时为false
private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
//将传入的参数赋值给对应的变量
this.client = client;
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
//生成一个RetryAndFollowUpInterceptor,用于失败重试以及重定向
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
}
然后通过execute()进行同步请求
@Override public Response execute() throws IOException {
synchronized (this) {
//如果该请求正在运行抛出异常，否则将运行标志位置为true，防止重复请求
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
//捕获调用堆栈的跟踪
captureCallStackTrace();
//告知eventlisten请求开始
eventListener.callStart(this);
try {
//通过dispatcher的executed来实际执行
client.dispatcher().executed(this);
//经过一系列"拦截"操作后获取结果
Response result = getResponseWithInterceptorChain();
//如果result为空抛出异常
if (result == null) throw new IOException("Canceled");
return result;
} catch (IOException e) {
//告知eventlisten请求失败
eventListener.callFailed(this, e);
throw e;
} finally {
//通知dispatcher执行完毕
client.dispatcher().finished(this);
}
}
在这一步中 client.dispatcher().executed(this) 仅仅是将call加入一个队列，并没有真正开始进行网络请求
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
真正开始进行网络请求的方法是getResponseWithInterceptorChain()，这也是此次网络请求中最为重要的一个方法
Response getResponseWithInterceptorChain() throws IOException {
//创建一个拦截器数组用于存放各种拦截器
List<Interceptor> interceptors = new ArrayList<>();
//向数组中添加用户自定义的拦截器
interceptors.addAll(client.interceptors());
//1.向数组中添加retryAndFollowUpInterceptor用于失败重试和重定向
interceptors.add(retryAndFollowUpInterceptor);
//2.向数组中添加BridgeInterceptor用于把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//3.向数组中添加CacheInterceptor用于读取缓存以及更新缓存
interceptors.add(new CacheInterceptor(client.internalCache()));
//4.向数组中添加ConnectInterceptor用于与服务器建立连接
interceptors.add(new ConnectInterceptor(client));
//如果不是webSocket添加networkInterceptors
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors());
}
//5.向数组中添加CallServerInterceptor用于从服务器读取响应的数据
interceptors.add(new CallServerInterceptor(forWebSocket));
//根据上述的拦截器数组生成一个拦截链
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
//通过拦截链的proceed方法开始整个拦截链事件的传递
return chain.proceed(originalRequest);
}
在getResponseWithInterceptorChain()方法中我们可以发现有许多不同功能的拦截器，主要列举一下默认已经实现的几个拦截器的作用：
- retryAndFollowUpInterceptor 负责失败重试和重定向
- BridgeInterceptor 负责把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。
- CacheInterceptor 负责读取缓存以及更新缓存
- ConnectInterceptor 负责建立连接
- CallServerInterceptor 负责发送和读取数据
而这些拦截器的具体实现我们后续在看，按照流程在这个方法中通过new RealInterceptorChain()生成了一个拦截链，然后通过它proceed()方法开始运行这条拦截链
//RealInterceptorChain的构造函数主要是将传入的参数用变量记录下来，其中的index参数用来记录当前的拦截器
public RealInterceptorChain(List<Interceptor> interceptors, StreamAllocation streamAllocation,
HttpCodec httpCodec, RealConnection connection, int index, Request request, Call call,
EventListener eventListener, int connectTimeout, int readTimeout, int writeTimeout) {
this.interceptors = interceptors;
this.connection = connection;
this.streamAllocation = streamAllocation;
this.httpCodec = httpCodec;
this.index = index;
this.request = request;
this.call = call;
this.eventListener = eventListener;
this.connectTimeout = connectTimeout;
this.readTimeout = readTimeout;
this.writeTimeout = writeTimeout;
}
//调用proceed传入request
@Override public Response proceed(Request request) throws IOException {
//在本例中streamAllocation、httpCodec、connection均为null
return proceed(request, streamAllocation, httpCodec, connection);
}
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
//当index大于拦截器数组的大小时抛出异常
if (index >= interceptors.size()) throw new AssertionError();
calls++;
// If we already have a stream, confirm that the incoming request will use it.
if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must retain the same host and port");
}
// If we already have a stream, confirm that this is the only call to chain.proceed().
if (this.httpCodec != null && calls > 1) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must call proceed() exactly once");
}
// Call the next interceptor in the chain.
// 实例化下一个拦截器的拦截链
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
//获取当前的拦截器
Interceptor interceptor = interceptors.get(index);
//调用当前拦截器的intercept()，并传入下一个拦截器的拦截链
Response response = interceptor.intercept(next);
// Confirm that the next interceptor made its required call to chain.proceed().
if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
throw new IllegalStateException("network interceptor " + interceptor
+ " must call proceed() exactly once");
}
// Confirm that the intercepted response isn't null.
if (response == null) {
throw new NullPointerException("interceptor " + interceptor + " returned null");
}
if (response.body() == null) {
throw new IllegalStateException(
"interceptor " + interceptor + " returned a response with no body");
}
return response;
}
每个拦截器的intercept()方法各不相同，下面按照前文的添加顺序具体分析其实现与功能
1.RetryAndFollowUpInterceptor
@Override public Response intercept(Chain chain) throws IOException {
//从传入拦截链中获取request、call、eventListener
Request request = chain.request();
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Call call = realChain.call();
EventListener eventListener = realChain.eventListener();
//创建一个StreamAllocation，传递给后面的拦截链，用于管理Connections、Streams、Calls三者之间的关系
streamAllocation = new StreamAllocation(client.connectionPool(), createAddress(request.url()),
call, eventListener, callStackTrace);
//记录重试次数
int followUpCount = 0;
Response priorResponse = null;
//开启循环
while (true) {
//判断是否取消，如果取消则通过streamAllocation释放连接并抛出IOException
if (canceled) {
streamAllocation.release();
throw new IOException("Canceled");
}
Response response;
boolean releaseConnection = true;
try {
//调用传入的拦截链的proceed方法，执行下一个拦截器，捕获抛出的异常并进行处理
response = realChain.proceed(request, streamAllocation, null, null);
releaseConnection = false;
} catch (RouteException e) {
//捕获到路由寻址异常，判断是否要恢复，否的话抛出异常
// The attempt to connect via a route failed. The request will not have been sent.
if (!recover(e.getLastConnectException(), false, request)) {
throw e.getLastConnectException();
}
releaseConnection = false;
continue;
} catch (IOException e) {
//捕获到IO异常，判断是否要恢复，否的话抛出异常
// An attempt to communicate with a server failed. The request may have been sent.
boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
if (!recover(e, requestSendStarted, request)) throw e;
releaseConnection = false;
continue;
} finally {
// We're throwing an unchecked exception. Release any resources.
//根据标志位releaseConnection判断是否需要释放连接
if (releaseConnection) {
streamAllocation.streamFailed(null);
streamAllocation.release();
}
}
// Attach the prior response if it exists. Such responses never have a body.
if (priorResponse != null) {
response = response.newBuilder()
.priorResponse(priorResponse.newBuilder()
.body(null)
.build())
.build();
}
//根据response来生成一个Request对象用于重定向和重连
Request followUp = followUpRequest(response);
//如果followUp为空，则说明无须重连或重定向，直接释放连接返回response
if (followUp == null) {
if (!forWebSocket) {
streamAllocation.release();
}
return response;
}
//调用ResponseBody的close方法，关闭stream和相关资源
closeQuietly(response.body());
//重连次数高于限定次数(20)直接释放连接抛出异常
if (++followUpCount > MAX_FOLLOW_UPS) {
streamAllocation.release();
throw new ProtocolException("Too many follow-up requests: " + followUpCount);
}
//Request的请求体属于不可重复提交的请求体则关闭连接抛出异常
if (followUp.body() instanceof UnrepeatableRequestBody) {
streamAllocation.release();
throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
}
//是否是同一连接
if (!sameConnection(response, followUp.url())) {
streamAllocation.release();
streamAllocation = new StreamAllocation(client.connectionPool(),
createAddress(followUp.url()), call, eventListener, callStackTrace);
} else if (streamAllocation.codec() != null) {
throw new IllegalStateException("Closing the body of " + response
+ " didn't close its backing stream. Bad interceptor?");
}
request = followUp;
priorResponse = response;
}
}
上述代码即为RetryAndFollowUpInterceptor intercept的实现流程，它主要负责失败重试和重定向。简化流程如下：
- 实例化StreamAllocation传入到接下来的拦截链中
- 开启循环，执行下一个调用链（拦截器），等待响应（Response)
- 如果等待响应（Response）的过程中抛出异常，根据异常决定是否进行重连或重定向，否：退出
- 根据响应生成的followUp决定是否进行重连或重定向，否：返回响应（Response）
- 关闭响应结果
- 判断重连数是否达到最大值，是：释放连接、退出
- 判断followUp的请求体是否能重复提交，否：释放连接、退出
- 检测是否为相同连接，否：重新实例化StreamAllocation
- 循环以上步骤
2.BridgeInterceptor
根据拦截链的proceed方法可知，会调用到BridgeInterceptor的intercept()方法
@Override public Response intercept(Chain chain) throws IOException {
//从传入拦截链中获取request以及requestBuilder
Request userRequest = chain.request();
Request.Builder requestBuilder = userRequest.newBuilder();
//获取request的请求体，若不为空则添加部分请求头信息
RequestBody body = userRequest.body();
if (body != null) {
MediaType contentType = body.contentType();
if (contentType != null) {
//添加contentType
requestBuilder.header("Content-Type", contentType.toString());
}
//根据contentLength确定添加Content-Length还是Transfer-Encoding
long contentLength = body.contentLength();
if (contentLength != -1) {
requestBuilder.header("Content-Length", Long.toString(contentLength));
requestBuilder.removeHeader("Transfer-Encoding");
} else {
requestBuilder.header("Transfer-Encoding", "chunked");
requestBuilder.removeHeader("Content-Length");
}
}
//若无自定义host,添加默认host
if (userRequest.header("Host") == null) {
requestBuilder.header("Host", hostHeader(userRequest.url(), false));
}
//若无自定义Connection,添加默认Connection（Keep-Alive）
if (userRequest.header("Connection") == null) {
requestBuilder.header("Connection", "Keep-Alive");
}
// If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
// the transfer stream.
boolean transparentGzip = false;
if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
transparentGzip = true;
requestBuilder.header("Accept-Encoding", "gzip");
}
//如果在创建OKHttpClient时创建的cookieJar不为NO_COOKIE，且cookie不为空则添加Cookie
List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
if (!cookies.isEmpty()) {
requestBuilder.header("Cookie", cookieHeader(cookies));
}
//若User-Agent为空，则添加默认User-Agent，默认为OkHttp版本号，该例为okhttp/3.9.1
if (userRequest.header("User-Agent") == null) {
requestBuilder.header("User-Agent", Version.userAgent());
}
//初始化添加了头信息的request并传入下一个拦截链中
Response networkResponse = chain.proceed(requestBuilder.build());
//请求完成后，根据返回的response存储cookies（如果需要，否则该方法不作任何操作）
HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());
Response.Builder responseBuilder = networkResponse.newBuilder()
.request(userRequest);
//判断服务器是否支持gzip压缩格式,如果支持则交给kio压缩
if (transparentGzip
&& "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
&& HttpHeaders.hasBody(networkResponse)) {
GzipSource responseBody = new GzipSource(networkResponse.body().source());
Headers strippedHeaders = networkResponse.headers().newBuilder()
.removeAll("Content-Encoding")
.removeAll("Content-Length")
.build();
responseBuilder.headers(strippedHeaders);
String contentType = networkResponse.header("Content-Type");
responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
}
//返回处理后的response
return responseBuilder.build();
}
上述代码就是BridgeInterceptor intercept的实现流程，它主要用于负责把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。简化流程如下：
- 根据request信息，为请求添加头信息
- 将封装好的request传入下一个拦截链,并返回Response
- 根据返回的response进行cookie、Gzip处理
- 返回处理好的Gzip
3.CacheInterceptor
@Override public Response intercept(Chain chain) throws IOException {
//读取配置中的候选缓存，读取序列依次为OkHttpClient中的cache、internalCache和null。
Response cacheCandidate = cache != null
? cache.get(chain.request())
: null;
long now = System.currentTimeMillis();
//根据cacheCandidate创建缓存策略
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
Request networkRequest = strategy.networkRequest;
Response cacheResponse = strategy.cacheResponse;
//缓存监测
if (cache != null) {
cache.trackResponse(strategy);
}
//若未找到合适的缓存关闭stream和相关资源
if (cacheCandidate != null && cacheResponse == null) {
closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
}
//若根据缓存策略，不适用网络请求即networkRequest为null，且无相应缓存，即cacheResponse为null，直接报错返回504
// If we're forbidden from using the network and the cache is insufficient, fail.
if (networkRequest == null && cacheResponse == null) {
return new Response.Builder()
.request(chain.request())
.protocol(Protocol.HTTP_1_1)
.code(504)
.message("Unsatisfiable Request (only-if-cached)")
.body(Util.EMPTY_RESPONSE)
.sentRequestAtMillis(-1L)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
}
//若不使用网络，缓存有效。直接返回缓存的Response
// If we don't need the network, we're done.
if (networkRequest == null) {
return cacheResponse.newBuilder()
.cacheResponse(stripBody(cacheResponse))
.build();
}
//若需要使用网络则通过拦截链启动下一个拦截器发起网络请求
Response networkResponse = null;
try {
networkResponse = chain.proceed(networkRequest);
} finally {
// If we're crashing on I/O or otherwise, don't leak the cache body.
if (networkResponse == null && cacheCandidate != null) {
closeQuietly(cacheCandidate.body());
}
}
//当本地有缓存
// If we have a cache response too, then we're doing a conditional get.
if (cacheResponse != null) {
//网络请求返回304，即缓存数据未过期，根据本地缓存响应和网络请求响应生成Response
if (networkResponse.code() == HTTP_NOT_MODIFIED) {
Response response = cacheResponse.newBuilder()
.headers(combine(cacheResponse.headers(), networkResponse.headers()))
.sentRequestAtMillis(networkResponse.sentRequestAtMillis())
.receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
.cacheResponse(stripBody(cacheResponse))
.networkResponse(stripBody(networkResponse))
.build();
networkResponse.body().close();
// Update the cache after combining headers but before stripping the
// Content-Encoding header (as performed by initContentStream()).
cache.trackConditionalCacheHit();
cache.update(cacheResponse, response);
return response;
} else {
//否则缓存数据过期，关闭缓存。
closeQuietly(cacheResponse.body());
}
}
//根据网络请求返回的数据生成response
Response response = networkResponse.newBuilder()
.cacheResponse(stripBody(cacheResponse))
.networkResponse(stripBody(networkResponse))
.build();
//如果需要OKHttpClient需要使用缓存
if (cache != null) {
//如果response存在body且允许缓存，则进行本地化缓存
if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
// Offer this request to the cache.
CacheRequest cacheRequest = cache.put(response);
return cacheWritingResponse(cacheRequest, response);
}
//有的请求方法会使缓存无效，此时清除缓存
if (HttpMethod.invalidatesCache(networkRequest.method())) {
try {
cache.remove(networkRequest);
} catch (IOException ignored) {
// The cache cannot be written.
}
}
}
//返回响应
return response;
}
上述代码即为CacheInterceptor的intercept()方法的运行流程，主要负责读取缓存以及更新缓存，简化流程如下：
- 读取OkhttpClient配置缓存，可能为null
- 生成相应的缓存策略
- 根据缓存策略如果不使用网络且无相应缓存，则直接返回504
- 根据缓存策略如果不使用网络但相应缓存，则直接返回缓存响应
- 根据缓存策略如果使用网络，则通过拦截链启动下一个拦截器发起网络请求
- 根据网络响应，确定缓存是否过期，若未过期(返回304)则返回缓存
- 如果缓存过期，关闭缓存并生成网络请求的response
- 根据缓存要求进行本地缓存
- 返回网络请求的response
4.ConnectInterceptor 负责建立连接
@Override public Response intercept(Chain chain) throws IOException {
//从传入的拦截链中获取request和streamAllocation(RetryAndFollowUpInterceptor中初始化传入)
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
//初始化HttpCodec，在newStream方法中会通过findHealthyConnection()方法依次尝试从当前连接、连接池、其他线路的连接池、新建连接的顺序中获取到RealConnection，然后通过RealConnection的newCodec方法分别根据Http2、Http协议生成httpCodec
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
//获取RealConnection
RealConnection connection = streamAllocation.connection();
Connection
//通过拦截链启动下一个拦截器,并将httpCodec和connection传入
return realChain.proceed(request, streamAllocation, httpCodec, connection);
}
上述代码即为ConnectInterceptor的intercept()方法的运行流程，负责连接的建立，简化流程如下：
- 读取OkhttpClient配置request和streamAllocation
- 初始化HttpCodec
- 获取RealConnection
- 通过拦截链启动下一个拦截器,并将2、3步的对象传入
5.CallServerInterceptor
@Override public Response intercept(Chain chain) throws IOException {
// 通过拦截链获取在ConnectInterceptor中完成初始化的HttpCodec和RealConnection，以及streamAllocation和request
RealInterceptorChain realChain = (RealInterceptorChain) chain;
HttpCodec httpCodec = realChain.httpStream();
StreamAllocation streamAllocation = realChain.streamAllocation();
RealConnection connection = (RealConnection) realChain.connection();
Request request = realChain.request();
long sentRequestMillis = System.currentTimeMillis();
//通知eventListener
realChain.eventListener().requestHeadersStart(realChain.call());
//写请求头
httpCodec.writeRequestHeaders(request);
realChain.eventListener().requestHeadersEnd(realChain.call(), request);
Response.Builder responseBuilder = null;
//若请求方法允许传输请求体，且request的请求体不为空
if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
//如果在请求头中存在"Expect：100-continue"，说明该请求需要等待服务器回复是否能够处理请求体，服务器若不接受请求体则会返回一个非空的编码
if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
httpCodec.flushRequest();
realChain.eventListener().responseHeadersStart(realChain.call());
//接收服务器的返回请求，服务器若不接受请求体则会返回一个非空的响应
responseBuilder = httpCodec.readResponseHeaders(true);
}
//若responseBuilder为null，则Expect不为100-continue或服务器接收请求体,开始写入请求体
if (responseBuilder == null) {
// Write the request body if the "Expect: 100-continue" expectation was met.
realChain.eventListener().requestBodyStart(realChain.call());
long contentLength = request.body().contentLength();
CountingSink requestBodyOut =
new CountingSink(httpCodec.createRequestBody(request, contentLength));
BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
request.body().writeTo(bufferedRequestBody);
bufferedRequestBody.close();
realChain.eventListener()
.requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);
} else if (!connection.isMultiplexed()) {
// 如果服务器拒绝接收请求体,且不是http2，则禁止此连接被重新使用
streamAllocation.noNewStreams();
}
}
//完成请求写入
httpCodec.finishRequest();
//通过httpCodec获取响应头
if (responseBuilder == null) {
realChain.eventListener().responseHeadersStart(realChain.call());
responseBuilder = httpCodec.readResponseHeaders(false);
}
//通过responseBuilder填入信息创建Response
Response response = responseBuilder
.request(request)
.handshake(streamAllocation.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
realChain.eventListener()
.responseHeadersEnd(realChain.call(), response);
//获取返回码
int code = response.code();
//如果是101（升级到Http2协议），则返回一个EMPTY_RESPONSE的响应体
if (forWebSocket && code == 101) {
// Connection is upgrading, but we need to ensure interceptors see a non-null response body.
response = response.newBuilder()
.body(Util.EMPTY_RESPONSE)
.build();
} else {
//写入服务器返回的响应体
response = response.newBuilder()
.body(httpCodec.openResponseBody(response))
.build();
}
//若请求或者服务器要求断开连接，则断开
if ("close".equalsIgnoreCase(response.request().header("Connection"))
|| "close".equalsIgnoreCase(response.header("Connection"))) {
streamAllocation.noNewStreams();
}
//若返回204/205(服务器均未返回响应体)且响应体长度大于）则抛出异常
if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
throw new ProtocolException(
"HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
}
//返回响应
return response;
}
上述代码即为CallServerInterceptor的intercept()方法的运行流程，负责发送请求数据和读取响应数据，简化流程如下：
- 读取HttpCodec、RealConnection等对象
- 写入请求头
- 若需要（由请求方法和服务器决定），写入请求体
- 读取响应头信息
- 若请求或响应要求断开连接，则断开连接
- 根据响应码读取响应体
- 处理204/205的异常情况
- 返回响应
至此默认的五个拦截器的实现和功能都已经分析完了，但由于篇幅有限，所以其中有些对象并没有深入分析，如streamAllocation、HttpCodec等
4.获取Response的响应结果
//4.返回请求结果
return response.body().string();
此时的response就是第三步中通过newCall获取到的response
public @Nullable ResponseBody body() {
return body;
}
//以Content-Type标头的字符集解码的字符串形式返回响应，若未标明则用UTF-8
public final String string() throws IOException {
BufferedSource source = source();
try {
Charset charset = Util.bomAwareCharset(source, charset());
return source.readString(charset);
} finally {
Util.closeQuietly(source);
}
}
结语
本篇分析了官方示例中get操作的流程，最大的特点则在于通过拦截器链来实现责任链链，从而完成整个网络请求的流程。
本篇文章是个人学习的总结，本人能力有限，如果有错误欢迎斧正，谢谢。
网友评论