接触okhttp其实挺长时间了，期间呢也了解过源码，现在趁不忙来总结一下。
okhttp是一款优秀的http请求框架 支持Get 和Post请求，支持基于http的文件上传下载，支持加载图片，支持下载文件透明的gzip压缩，支持超时重连与请求缓存，支持响应缓存避免重复的网络请求，支持使用连接池来降低响应延迟问题。
注：此次源码基于OK 3.8.0
我们先从OK的基本流程开始，
OkHttpClient client = new OkHttpClient();
Request mRequest = new Request.Builder().url(url).build();
Call mCall = client.newCall(mRequest);
首先创建出 OkHttpClient 的实例，通过源码我们可以看出，它是通过建造者模式来实现的，可以对整体请求的参数进行设置（如：分发器Dispatcher ，超时时间，拦截器等）。然后创建出Request的实例，最后将 Request 添加到请求中。
public OkHttpClient() {
this(new Builder());
}
我们重点看请求的方法的实现:
/**
* Prepares the {@code request} to be executed at some point in the future.
*/
@Override public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
其实Call是一个接口，具体的请求是通过RealCall来实现的，首先我们来看RealCall 的异步（enqueue ）方法
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
//
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
这里的 client 就是我们之前创建的OkHttpClient 实例。AsyncCall 间接实现了Runnable接口 ，通过dispatcher的enqueue方法讲runnable实例添加到线程池队列，我们接着看 dispatcher 的 enqueue 方法
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
其实上面方法的操作很简单，就是将请求添加到线程池队列中，并启动线程池。到这里的时候我们发现，虽然找到了线程池，但是并没有找到具体执行网络请求的操作。其实具体的操作就在刚才的AsyncCall类中，AsyncCall为RealCall中的内部类，使用final修饰，不可被继承。
//NamedRunnable 实现了Runnable的接口 所以AsyncCall 也间接的实现类Runnable接口
final class AsyncCall extends NamedRunnable {
***
@Override protected void execute() {
boolean signalledCallback = false;
try {
Response response = getResponseWithInterceptorChain();
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 {
client.dispatcher().finished(this);
}
}
***
}
通过以上代码我们发现 只是通过一个方法便获取到了Response ，那我们看一下这个方法的具体实现
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> interceptors = new ArrayList<>();
//用户自定义添加的拦截器 如 打印请求的拦截器
interceptors.addAll(client.interceptors());
//负责失败重试以及重定向的拦截器
interceptors.add(retryAndFollowUpInterceptor);
//负责把用户构造的请求转换为发送到服务器的请求、把服务器返回的响应转换为用户的响应的拦截器
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//负责缓存的拦截器
interceptors.add(new CacheInterceptor(client.internalCache()));
//负责和服务器建立连接的拦截器
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
//配置 OkHttpClient 时设置的网络拦截器
interceptors.addAll(client.networkInterceptors());
}
//负责与服务器通信的连接器（发送请求，接受响应）
interceptors.add(new CallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
这里就来到了我们的重点 --- 拦截器，okhttp所有的具体网络操作，缓存等都是由拦截器链来完成的，整个拦截器链采用了责任链模式，通过 RealInterceptorChain 的 proceed 方法，开始整个拦截器链的运行
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
//省略部分代码
calls++;
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(
interceptors, streamAllocation, httpCodec, connection, index + 1, request);
//从拦截器集合中获取一个拦截器，
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
//省略部分代码
return response;
}
我们下接着看一下拦截器的intercept 方法，然后在对整个拦截器的工作流程进行分析，当然每个拦截器的intercept 方法中具体实现是不同的，我们调其中一个来看一下
@Override public Response intercept(Chain chain) throws IOException {
//其实我们要看的就时这一行代码
Response networkResponse = chain.proceed(requestBuilder.build());
//省略部分代码
return responseBuilder.build();
}
现在我们结合以上代码来对整个拦截器链的工作流程进行分析，首先看RealInterceptorChain 类的 proceed方法，其实该方法是个递归方法，首先 通过对index的控制来获取链中的拦截器，然后调用interceptor 的intercept方法，在intercept中又会调用新的RealInterceptorChain 实例的
proceed方法，就这样直到所有拦截器都执行后，对结果处理后返回Response。最后回到RealCall的getResponseWithInterceptorChain方法
以上就是对okhttp的整体流程的基本概况，上面呢我们是通过异步来实现的，现在再把同步任务简单说一下：
关于ok的同步任务就不上代码了，其实它与异步的不同处在于，同步并没有使用线程池，仅此而已，还是通过getResponseWithInterceptorChain方法来开启整个流程的。
如有问题，请指正
网友评论