OkHttp3深度源码解析(一)，体会OkHttp3设计模式的妙处

一、okhttp背景…

二、使用步骤

1、创建OkHttpClient;

OkHttpClient okHttpClient = new OkHttpClient.Builder().build();

这一个过程到底做了什么？

最张调用 OkHttpClient(Builder builder)得到实例并赋值。

赋值了哪些参数？

private OkHttpClient(Builder builder) {
this.dispatcher = builder.dispatcher;
this.proxy = builder.proxy;
this.protocols = builder.protocols;
this.connectionSpecs = builder.connectionSpecs;
this.interceptors = Util.immutableList(builder.interceptors);
this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
this.proxySelector = builder.proxySelector;
this.cookieJar = builder.cookieJar;
this.cache = builder.cache;
this.internalCache = builder.internalCache;
this.socketFactory = builder.socketFactory;

boolean isTLS = false;
for (ConnectionSpec spec : connectionSpecs) {
isTLS = isTLS || spec.isTls();
}

if (builder.sslSocketFactory != null || !isTLS) {
this.sslSocketFactory = builder.sslSocketFactory;
this.certificateChainCleaner = builder.certificateChainCleaner;
} else {
X509TrustManager trustManager = systemDefaultTrustManager();
this.sslSocketFactory = systemDefaultSslSocketFactory(trustManager);
this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
}

this.hostnameVerifier = builder.hostnameVerifier;
this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(
certificateChainCleaner);
this.proxyAuthenticator = builder.proxyAuthenticator;
this.authenticator = builder.authenticator;
this.connectionPool = builder.connectionPool;
this.dns = builder.dns;
this.followSslRedirects = builder.followSslRedirects;
this.followRedirects = builder.followRedirects;
this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
this.connectTimeout = builder.connectTimeout;
this.readTimeout = builder.readTimeout;
this.writeTimeout = builder.writeTimeout;
}

参数解释：

1)dispatcher：请求的执行器，负责请求的同步执行、异步执行、取消、以及最多可以同时执行的请求数。

包含三个请求队列：

readyAsyncCalls，准备执行的异步请求列队，（当同时请求数大于maxRequests时，会将请求存入到这列队）

runningAsyncCalls：正在执行的异步请求列队(未取消和未结束)

runningSyncCalls：正在执行的同步请求列队(未取消和未结束)

2)proxy：网络的代理设置，可以通过他给网络请求设置代理

3)protocols：支持的Protocol协议，Protocol和Url类似，java.net.URI.getScheme()返回url的协议(http, https, etc),而Protocol.get()返回的协议更加具体(http/1.0,http/1.1,h2,etc)

4)connectionSpecs : 支持套接字连接协议.

5)interceptors： 拦截器。可观察每个调用的全部跨度

6)networkInterceptors : 拦截器。可观察一个网络请求和响应

7)proxySelector ：代理服务器选择器

8)cookieJar ：提供cookie可持久化操作。

9)cache：缓存

10)internalCache：okhttp的内部缓存，使用者不应该使用它，用cache即可。

11)socketFactory ：创建套接字的工厂类

12)sslSocketFactory：创建ssl套接字工厂类

13)certificateChainCleaner：证书

14)hostnameVerifier：主机名验证

15)certificatePinner：约束所信任的证书

16)proxyAuthenticator：身份验证代理服务器

17)authenticator：身份验证代理服务器

18)connectionPool：连接池用于回收利用HTTP和HTTPS连接。

19)dns：dns服务器;默认使用系统的

20)followSslRedirects：是否支持sslhttp重定向,默认true

21)followRedirects：是否支持http重定向,默认true

22)retryOnConnectionFailure：连接失败时是否重试,默认true

23)connectTimeout：连接超时

24)readTimeout：读取超时

25)writeTimeout：写入超时

参数有些多，大致了解可以帮我们更容易理清okhttp整体流程

2、创建Request;

private Request(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = builder.headers.build();
this.body = builder.body;
this.tag = builder.tag != null ? builder.tag : this;
}

参数说明,这个看着清爽:

1)url：请求地址

2)method ：请求方法

3)headers ：请求头

4)body：请求体

5)tag：请求标记

3、创建Call,

Call = okHttpClient.newCall(Request);

实际上调用了

protected RealCall(OkHttpClient client, Request originalRequest) {
this.client = client;
this.originalRequest = originalRequest;
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client);
}

这里添加 retryAndFollowUpInterceptor 拦截器，通过这个拦截实现了重新请求及取消请求功能

4、重头戏来了。(这里先看看异步请求)，enqueue(Callback responseCallback);

1）开始执行请求：

synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}

如果已经被执行就抛异常，所以一个call就能调一次execute、enqueue。

2） client.dispatcher().enqueue(new AsyncCall(responseCallback));

调用该请求的client的执行器来执行该请求。

这里先创建了一个Runable的子类AsyncCall。

3）dispatcher 类中

synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}

看看请求列表有没有满。没有满，加入到正在执行列表，然后直接执行。否则放到等待队列。

4）AsyncCall类中，直接在代码中注解了

@Override protected void execute() {
//标记有没有执行回调
boolean signalledCallback = false;
try {
//核心、获取到response，看下面注释
Response response = getResponseWithInterceptorChain();

//如果取消的就直接回调onFailure,传入new IOException("Canceled")异常。
if (retryAndFollowUpInterceptor.isCanceled()) {
signalledCallback = true;
responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
} else {
signalledCallback = true;
responseCallback.onResponse(RealCall.this, response);
}
} catch (IOException e) {
if (signalledCallback) {
// Do not signal the callback twice!
Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
} else {
responseCallback.onFailure(RealCall.this, e);
}
} finally {
//最后，结束这个call,看下面
client.dispatcher().finished(this);
}
}

private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
int runningCallsCount;
Runnable idleCallback;
synchronized (this) {
if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
if (promoteCalls) promoteCalls();//promoteCalls()是为了在满足要下（正在执行的异步任务数小于maxRequests）把准备请求列里的请求转至正在请求队列，并执行它。
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}

if (runningCallsCount == 0 && idleCallback != null) {
idleCallback.run();//如果分发器没有需要执行的工作，处理idle状态，会执行该回调
}
}

RealCall类里面
private Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> interceptors = new ArrayList<>();

//下面是添加一系列拦截器，个人觉得这里是体现okhttp精华所在的胜地，看到这里，都会激动的不要不要的！
interceptors.addAll(client.interceptors());
//网络重试及取消的处理
interceptors.add(retryAndFollowUpInterceptor);
//cookie处理
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//okhttp的内部缓存处理
interceptors.add(new CacheInterceptor(client.internalCache()));
//打开目标服务器的连接
interceptors.add(new ConnectInterceptor(client));

//如果不是forWebSocket，添加网络重试及取消拦截器
if (!retryAndFollowUpInterceptor.isForWebSocket()) {
interceptors.addAll(client.networkInterceptors());
}
网络请求在这个拦截器里面
interceptors.add(new CallServerInterceptor(
retryAndFollowUpInterceptor.isForWebSocket()));

Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}

RealInterceptorChain类中 贴出核心代码
public Response proceed(Request request, StreamAllocation streamAllocation, HttpStream httpStream,
Connection connection) throws IOException {
if (index >= interceptors.size()) throw new AssertionError();

Call the next interceptor in the chain.
获取到下个拦截(拦截是从0开关顺序执行的，结后执行是的CallServerInterceptor拦截器，所以在CallServerInterceptor拦截器中就看不到Chain.proceed(Request request)了)
RealInterceptorChain next = new RealInterceptorChain(
interceptors, streamAllocation, httpStream, connection, index + 1, request);
Interceptor interceptor = interceptors.get(index);
//让下个拦截去处理所要处理的逻辑
Response response = interceptor.intercept(next);

return response;
}

三、总结

看完后

美妙无穷