前言
前面一节我们讲解了 同步请求和异步请求的实际使用方式，并分析了两种方式的区别。这里我们回顾下：
- 同步请求和异步的发送实际分为了4个步骤，其中前三个步骤是相同的；分别是创建OkhttpClient、request、和Call对象； 不同的是同步调用的是Call对象的
execute()方法，而异步调用的是enqueue()方法。 - 同步请求会阻塞等待，异步请求在子线程中执行则不会阻塞。
请参考上一章节：
OKhttp3 的同步和异步请求基本用法
其他相关文章
OkHttp 4.0 Kotlin源码分析 (一) 同步和异步请求基本用法
OkHttp 4.0 Kotlin源码分析 (二) 基本的数据对象以及Call类分析
OkHttp 4.0 Kotlin源码分析 (三) Dispatcher分发器流程控制
那么我们每个步骤中的对象是什么，分别做了什么工作呢？ 在接下来的这个章节我将对其进行解析。
2. Okhttp3 的对象解析
2.1 Okhttp3 请求的执行流程图
同步和异步请求结构
2.2 OkHttpClient客户端类
OkhttpClient是由一个静态内部内Builder进行创建，我们看下这个Builder的构造方法。其中初始化了OkhttpClient对象的初始化工作，而且其中包括两个非常重要的对象，分别是分发器（Dispather）和连接池（ConnectionPool）。
public Builder() {
//1. Dispatcher是http请求的分发器； 这是Okhttp的核心之一，
// 主要完成的任务是处理缓冲策略，不管是同步请求还是异步请求都是经过这个Dispatcher进行分发处理
dispatcher = new Dispatcher();
protocols = DEFAULT_PROTOCOLS;
connectionSpecs = DEFAULT_CONNECTION_SPECS;
eventListenerFactory = EventListener.factory(EventListener.NONE);
proxySelector = ProxySelector.getDefault();
if (proxySelector == null) {
proxySelector = new NullProxySelector();
}
cookieJar = CookieJar.NO_COOKIES;
socketFactory = SocketFactory.getDefault();
hostnameVerifier = OkHostnameVerifier.INSTANCE;
certificatePinner = CertificatePinner.DEFAULT;
proxyAuthenticator = Authenticator.NONE;
authenticator = Authenticator.NONE;
// ConnectionPool 连接池，这也是我们上一节讲到的四大特性之一。主要作用是：
// a. 管理客户和服务器之间的连接，并对连接进行复用。
// b. 对于连接策略进行管理以提高连接效率
connectionPool = new ConnectionPool();
dns = Dns.SYSTEM;
followSslRedirects = true;
followRedirects = true;
retryOnConnectionFailure = true;
callTimeout = 0;
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
2.2 Request请求报文信息类
和OkhttpClient相同，Request也是使用的是Build创建模式，对于需要大量参数进行初始化操作的对象使用Build创建模式是非常好的一个策略。这个类创建了 HTTP请求所需要的信息
// Builder内部类的构造方法
public Builder() {
this.method = "GET";
// 创建Http请求所需要的头部信息
this.headers = new Headers.Builder();
}
// 将创建的Builder 信息传递给Request的构造方法
public Request build() {
if (url == null) throw new IllegalStateException("url == null");
return new Request(this);
}
//构造方法初始化了请求所需要的信息： url 、 请求方法、 头部信息、 body等
Request(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = builder.headers.build();
this.body = builder.body;
this.tags = Util.immutableMap(builder.tags);
}
2.3 call 请求/响应对象
Call 是为执行而准备的请求。这个对象代表的是一个请求响应流，只能被执行一次，并且是可以取消的。
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
Call是一个Interface， 实际的逻辑是在它的实现类RealCall中。
// 这个静态方法 创建了一个RealCall对象，并创建赋值了一个回调监听
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
// Safely publish the Call instance to the EventListener.
RealCall call = new RealCall(client, originalRequest, forWebSocket);
call.eventListener = client.eventListenerFactory().create(call);
return call;
}
private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
// OkHttpClient对象
this.client = client;
// request对象
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
// 重定向拦截器 是Okhttp的核心之一， 在创建Call的时候进行了创建
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
this.timeout = new AsyncTimeout() {
@Override protected void timedOut() {
cancel();
}
};
this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
}
Okhttp 3.13 版本引入了lambda 表达式，看着下面的代码是不是一脸蒙圈？
实现的作用是创建了一个EventListerner.Factory
static EventListener.Factory factory(EventListener listener) {
return call -> listener;
}
--> 其实他是这个样子的, 创建了一个create返回listener的EventListener的Factory;
而这个Factory是在OkhttpClient创建时创建的。
static EventListener.Factory factory(final EventListener listener) {
return new EventListener.Factory() {
public EventListener create(Call call) {
return listener;
}
};
}
3. Call 源码分析
3.1 Call 的同步请求方法 executed() 分析
@Override public Response execute() throws IOException {
// 前面说到Call对象只能被执行一次， 那么是怎么保证的呢？
// a. 通过这个executed 进行状态标记，
// b. 加入对象锁
// 多线程同一个call对象也只能被执行一次，否则抛出IllegalStateException异常
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
timeout.enter();
eventListener.callStart(this);
/**这块核心代码*/
try {
// 这是关键步骤， 调用Dispatcher中的 executed 方法；
// 这里并没有执行， 而是将Call加入到执行队列中
client.dispatcher().executed(this);
// 获取response 的责任链的执行结果 ， 这是Okhttp设计非常巧妙的地方，后面会进行详细讲解
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} catch (IOException e) {
e = timeoutExit(e);
eventListener.callFailed(this, e);
throw e;
} finally {
// 在Dispatcher中将Call对象 从执行列表中移除掉
// 这将在下一节 Dispatcher进行详细讲解
client.dispatcher().finished(this);
}
}
我们发现 Call的executed()方法
- 调用了
dispatcher.executed()和dispatcher.finished()方法，实际上是将Call对象加入到同步执行队列,然后移除。 - 调用了
getResponseWithInterceptorChain并同步返回执行结果。
3.2 Call 的异步请求方法 enqueue() 分析
@Override public void enqueue(Callback responseCallback) {
// 这个和 execute() 方法是一样的
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
// 1. 将Callback 封装成Asyncall对象（实际是一个Runnable）
// 2. 将call对象添加到异步等待队列并调度执行
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
异步请求做了两件事：
- 将Callback 封装成Asyncall对象（实际是一个Runnable）
- 将call对象添加到异步等待队列并由Dispatcher调度执行
3.3 Call 取消请求 cancel() 分析
// Call 代码
@Override public void cancel() {
retryAndFollowUpInterceptor.cancel();
}
// retryAndFollowUpInterceptor 对象取消代码
public void cancel() {
canceled = true;
StreamAllocation streamAllocation = this.streamAllocation;
if (streamAllocation != null) streamAllocation.cancel();
}
3.4 总结
这一章节讲解了Okhttp使用过程中创建的各个数据对象的作用，和创建流程。详细分析了Call的实现类Realcall的源码，针对同步和异步请求有了更深层次的理解。
同步方法直接调用了
dispatcher().executed()添加到同步队列中； 阻塞获取请求结果 getResponseWithInterceptorChain()； 然后调用Finish() 方法回收call对象。异步请求主要的调度工作在Dispatcher中，我们将在下一章节讲解。在ReallCall中异步请求所做的工作是将CallBack封装成Runnable，并添加到Dispatcher的异步请求队列中。
对于异步请求到底是怎么调度的 ， 异步线程池又是以什么方式使用呢 ？
接下来我们讲解调度器Dispatcher
