OkHttp这个库有多优秀作为Androider大家心里都明白，应该说合格的开发者都认识它。那么，这里简单看个OKHttp的接口请求姿势：
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
.url("https://www.xxxx.com/xxx/xxx/xxx")
.build();
Call call = okHttpClient.newCall(request);
//开始执行异步接口请求
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
// 这里接口请求失败
}
@Override
public void onResponse(Call call, Response response) throws IOException {
// 这里接口请求成功
}
});
所以很明显了弄懂了上面几个类的是干嘛、上个几个流程做了什么自然就明白了OKHttp的执行流程了，那么就开始分析吧。
OKHttp请求中需要的对象
Request这个类是典型的'Builder'设计模式，看一眼他的成员属性就知道这个类是干嘛的了。
public final class Request {
final HttpUrl url;
final String method;
final Headers headers;
final @Nullable RequestBody body;
final Object tag;
.
.
.
}
看看变量名就知道了这个类封装那些玩意，还是很愉快的完成了一小步。
OkHttpClient这个类类似个Manager类，里面的成员属性自然也比较多了。
我们重点关注Dispatcher这个线程池属性：
// 可以传入线程池，从而自定义OKHttp线程池
public Dispatcher(ExecutorService executorService) {
this.executorService = executorService;
}
public Dispatcher() {
}
// 初始化线程池
public synchronized ExecutorService executorService() {
if (executorService == null) {
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
所以Dispatcher就是一个线程池管理类，用于分发每一次的Http请求。
Call是接口真正的实现类是RealCall，而RealCall有个内部类叫AsyncCall是个接口，最终加入Dispatcher线程池的就是AsyncCall对象。
执行Http请求操作
我们从okHttpClient.newCall操作开始阅读：
/**
* 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 */);
}
所以这里封装了一个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));
}
再看最后一行代码会执行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是实现了NamedRunnable接口，所以线程池就会执行NamedRunnable.run方法，这样子自然就执行到AsyncCall.execute方法。
@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);
}
}
}
我们可以看到这里直接通过getResponseWithInterceptorChain()方法直接得到Response然后通过Callback回调数据回去。
拦截器Interceptor
通过上面我们知道已经得到Response基本上可以说已经结束了一个流程，这里并不细节的解释每个拦截器的代码，只是介绍一下拦截器的调用时序，所以仍然先看一下getResponseWithInterceptorChain方法：
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) {
interceptors.addAll(client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
我们可以看到系统已经为我们定义几个默认的拦截器，他们的作用一起调用时序如下：
这里知道了调用时序，那从什么时候触发调用？
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
我们可以看到是先封装一个RealInterceptorChain对象，然后执行proceed方法自然就会执行每一个interceptor.intercept方法。OKHttp的所有精髓之一就是拦截器的使用..
最后，这里我们也可以明白一点addInterceptor / addNetworkInterceptor两者之间有何不同了，因为他们俩的调用时序不一样。
更多拦截器的分析，将在未来找时间分析。
