前言
OKhttp是一个优秀的网络请求框架，目前已被谷歌加入Android源码中，相信目前大部分的开发者都在使用，不论是搭配retrofit还是直接使用OKhttp，都给我们带来极大的方便。
谷歌官方都已经采用的方案，我们不能仅仅只停留在会用的阶段，要知其然更要知其所以然。所以今天就跟随源码记录一下OKhttp内部的原理，也学习一下其中的思想。
代码跟踪
同步请求方式
/**
* 同步请求
* 接口地址 https://gank.io/api/today
* GET
*/
public void syncCall() {
//初始化一个OKhttpClient
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("https://gank.io/api/today")
.get()
.build();
try {
//同步请求
Response response = client.newCall(request).execute();
if (response.isSuccessful()) {
Log.i(TAG, "success: ");
}
} catch (IOException e) {
e.printStackTrace();
}
}
OKhttpClient的创建方式有两种，一种是我们上面使用的，直接new一个实例对象，使用其中的默认参数，另一种就是通过builder的方式创建，可以通过builder更改一些默认的配置，比如添加自定义拦截器，更改缓存策略、超时时间等，我们主要把握整体的流程，这里就不分析具体的字段了。
所有的请求都是通过call接口来实现的，其内部封装了同步和异步请求的接口
@Override
public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
Call只是一个抽象的接口，真正的实现是在RealCall里面，通过newRealCall初始化一个真正的Call实例
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;
}
RealCall执行真正的网络请求
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
timeout.enter();
eventListener.callStart(this);
try {
client.dispatcher().executed(this);
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 {
client.dispatcher().finished(this);
}
}
分析：一个call只能被执行一次，如果当前call已被执行过，就会抛出一个异常；如果请求未执行，则进入client.dispatcher.executed(this)方法；此方法将本身实例（call）传入，接下来看一下dispatcher中的executed方法
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
dispatcher里面维护了三个Deque，分别为readyAsyncCalls、runningAsyncCalls、runningSyncCalls，可以看出前两个是异步请求需要的，稍后分析异步的时候再详细介绍；我们这里主要关注runningSyncCalls。
上面的方法中仅仅是把call请求加入到同步请求队里中，方便后续管理请求的状态，并没有做别的操作，核心代码是在
Response result = 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);
}
这里真正去请求网络，通过不同的拦截器，采用责任链模式，获取网络回复，这是一个阻塞操作，会一直等待执行完毕并获取结果，然后执行finally中的finish方法，
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();
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}
if (runningCallsCount == 0 && idleCallback != null) {
idleCallback.run();
}
}
方法中第一个参数为runningSyncCalls队列，第二个参数为当前已经执行的call请求，第三个参数为异步请求标志，true为异步，false为同步，然后将当前的call从队列中移除，因为我们没有设置idleCallback，所以当finish结束以后，整个同步请求的过程也就结束了。
因为获取请求的过程是一个阻塞的过程，所以不能放在主线程，要开启子线程去请求网络。
------------------------------------------------------------------------------------------
因水平有限，如有错误请指正，不胜感激！
