本人通过源码的解读，只是为了加深对其执行流程的理解，文章中不会对更细致的地方做过多的讲解，只是把握住开源框架的整体脉络。
首先放上一个简单使用的例子：
OkHttpClient client = new OkHttpClient.Builder().build();
Request request = new Request.Builder().url("http://www.baidu.com").build();
Call call = client.newCall(request);
//同步请求
try {
Response response = call.execute();
response.close();
} catch (IOException e) {
e.printStackTrace();
}
//异步请求
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
//todo failure
}
@Override
public void onResponse(Call call, Response response) throws IOException {
//todo response
}
});
如上可以看到OkHttp有两种数据请求方式：同步和异步，其中请求Call是一个接口，实际由RealCall执行。
同步请求方式
public Response execute() throws IOException {
......
Response var2;
try {
...
Response result = this.getResponseWithInterceptorChain();
...
var2 = result;
} catch (IOException var7) {
this.eventListener.callFailed(this, var7);
throw var7;
} finally {
this.client.dispatcher().finished(this);
}
return var2;
}
getResponseWithInterceptorChain是一个链式调用的一个方法，该方法是OkHttp的一个精华部分，暂且不讲。
整个同步请求方式还是比较简单的，Call通过execute方法直接请求数据，以及接受数据成功或者失败的回调。
异步请求方式
// RealCall.java
public void enqueue(Callback responseCallback) {
......
this.client.dispatcher().enqueue(new RealCall.AsyncCall(responseCallback));
}
// Dispatcher.java
/**
* 这里有个小细节，异步请求不会是用多少请求就一定会立即会开始多少条请求，而是有个请求数量上限的。
* 只有执行队列的数量<最大请求数，并且正在请求的host数<最大请求host数时才会请求，否则就暂时放在就绪队列里缓存起来
*/
synchronized void enqueue(AsyncCall call) {
if(this.runningAsyncCalls.size() < this.maxRequests
&& this.runningCallsForHost(call) < this.maxRequestsPerHost) {
this.runningAsyncCalls.add(call);
this.executorService().execute(call);
} else {
this.readyAsyncCalls.add(call);
}
}
final class AsyncCall extends NamedRunnable {
private final Callback responseCallback;
......
protected void execute() {
boolean signalledCallback = false;
try {
// 1、请求结果
Response response = RealCall.this.getResponseWithInterceptorChain();
// 2、结果回调
if(RealCall.this.retryAndFollowUpInterceptor.isCanceled()) {
signalledCallback = true;
this.responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
} else {
signalledCallback = true;
this.responseCallback.onResponse(RealCall.this, response);
}
} catch (IOException var6) {
// 3、失败处理
if(signalledCallback) {
Platform.get().log(4, "Callback failure for " + RealCall.this.toLoggableString(), var6);
} else {
RealCall.this.eventListener.callFailed(RealCall.this, var6);
this.responseCallback.onFailure(RealCall.this, var6);
}
} finally {
// 4、结束
RealCall.this.client.dispatcher().finished(this);
}
}
}
public abstract class NamedRunnable implements Runnable {
public final void run() {
...
this.execute();
...
}
protected abstract void execute();
}
如上流程可以看出，异步方式就是将RealCall通过包装成AsyncCall，然后在线程池中进行数据请求，然后执行返回数据成功或者失败的处理。
通过以上的分析可以看出，OkHttp无论同步还是异步数据请求，整体的逻辑还是比较简单的，同步就直接在主线程中进行数据请求，异步就是在异步线程池中进行数据请求
无论同步还是异步请求，都有一个非常重要的一个方法：getResponseWithInterceptorChain()，这个方法也是OkHttp的精髓所在。下面具体开始分析该方法的实现。
getResponseWithInterceptorChain方法的实现逻辑分析
Response getResponseWithInterceptorChain() throws IOException {
List<Interceptor> interceptors = new ArrayList();
// 用户自定义的拦截器列表
interceptors.addAll(this.client.interceptors());
interceptors.add(this.retryAndFollowUpInterceptor);
interceptors.add(new BridgeInterceptor(this.client.cookieJar()));
interceptors.add(new CacheInterceptor(this.client.internalCache()));
interceptors.add(new ConnectInterceptor(this.client));
if(!this.forWebSocket) {
interceptors.addAll(this.client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(this.forWebSocket));
// 注意第5个参数传递的是0
Chain chain = new RealInterceptorChain(interceptors, (StreamAllocation)null, (HttpCodec)null, (RealConnection)null, 0, this.originalRequest, this, this.eventListener, this.client.connectTimeoutMillis(), this.client.readTimeoutMillis(), this.client.writeTimeoutMillis());
return chain.proceed(this.originalRequest);
}
如上可以看出OkHttp除了用户自定义的拦截器之外，主要包括如下几个拦截器RetryAndFollowUpInterceptor、BridgeInterceptor、CacheInterceptor、ConnectInterceptor、NetworkInterceptor和CallServerInterceptor。这几大拦截器共同组成了一个拦截器链，并封装到RealInterceptorChain这个对象当中。
既然是个拦截链，那OkHttp又是如何一条链一条链来进行数据拦截的呢？
下面再看看它的proceed的实现：
public Response proceed(Request request) throws IOException {
return this.proceed(request, this.streamAllocation, this.httpCodec, this.connection);
}
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection connection) throws IOException {
...
// 注意第5个参数为index+1
RealInterceptorChain next = new RealInterceptorChain(this.interceptors, streamAllocation, httpCodec, connection, this.index + 1, request, this.call, this.eventListener, this.connectTimeout, this.readTimeout, this.writeTimeout);
Interceptor interceptor = (Interceptor)this.interceptors.get(this.index);
Response response = interceptor.intercept(next);
...
return response;
}
这里大家只看到了其似乎只提取了一条拦截器，如何才能链式调用拦截器？这就是OkHttp设计的一个巧妙之处，正是通过interceptor.intercept(next)来不断的获取下一条拦截器进行数据拦截，然后返回最终的response。
Intercepter是一个接口，这里我拿RetryAndFollowUpInterceptor举例：
public Response intercept(Chain chain) throws IOException {
......
RealInterceptorChain realChain = (RealInterceptorChain)chain;
response = realChain.proceed(request, this.streamAllocation, (HttpCodec)null, (RealConnection)null);
......
return response;
}
看到没有，类似这个拦截器一样，每个拦截器都会最终调用realChain.proceed来不断获取下一个拦截器对返回数据进行拦截处理，从而最终得到处理后成功或者失败的数据。
