RxJava源码的基础部分分析的差不多，后续如果有新的内容话，会继续的补充。从今天开始，我们来看看OkHttp的相关源码。OkHttp的源码过于复杂，涉及到的方面非常的多，本系列文章目的是打通Okhttp的整个执行流程，不对某一个细节重点分析。
本篇文章是本系列文章的第一篇，我们先从最简单的Okhttp使用入手，进而分析Okhttp两种请求方式的流程。
1. 同步请求
同步请求的重点在于同步二字，顾名思义，执行同步请求，不会单独的开一个线程，所以在进行网络请求时，当前线程会阻塞在这里。
我们来简单的看看，怎么进行一个同步请求：
private final OkHttpClient mOkHttpClient = new OkHttpClient.Builder().readTimeout(50, TimeUnit.SECONDS).build();
private void syncRequest() {
Request request = new Request.Builder().url("http://www.baidu.com").get().build();
Call call = mOkHttpClient.newCall(request);
try {
Response response = call.execute();
} catch (IOException e) {
e.printStackTrace();
}
}
同步请求的执行是调用了call的execute方法。但是在调用execute方法之前，还要进行一些准备操作。
(1). OkHttpClient的创建
OkHttpClient是一个非常基础的类，在使用OkHttp来进行网络请求时，我们必须先创建OkHttpClient的对象。在这个类里面，我们会配置很多的参数，比如超时连接时间、拦截器等等。我们来详细的看一看：
private final OkHttpClient mOkHttpClient = new OkHttpClient.Builder()
.readTimeout(50, TimeUnit.SECONDS)
.build();
上面就是一个非常简单的创建列子。现在我们来从源码的角度来看看OkHttpClient究竟给我们配置那些参数。
我们知道OkHttpClient是通过建造者模式来创建的，我们先来看看OkHttpClient.Builder这个类的构造方法：
public Builder() {
dispatcher = new Dispatcher();
protocols = DEFAULT_PROTOCOLS;
connectionSpecs = DEFAULT_CONNECTION_SPECS;
eventListenerFactory = EventListener.factory(EventListener.NONE);
proxySelector = ProxySelector.getDefault();
cookieJar = CookieJar.NO_COOKIES;
socketFactory = SocketFactory.getDefault();
hostnameVerifier = OkHostnameVerifier.INSTANCE;
certificatePinner = CertificatePinner.DEFAULT;
proxyAuthenticator = Authenticator.NONE;
authenticator = Authenticator.NONE;
connectionPool = new ConnectionPool();
dns = Dns.SYSTEM;
followSslRedirects = true;
followRedirects = true;
retryOnConnectionFailure = true;
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
额，构造方法里面初始化我们很多的东西，这里我们需要看两个东西：
dispatcher = new Dispatcher();
connectionPool = new ConnectionPool();
Dispatcher是一个分发器，我们所有的Request请求都是通过Dispatcher分发的。在后续的文章，我会详细讲解这个类。本文就不对它做过多的解释。
ConnectionPool是一个连接池，很多的请求连接都由这个类管理，比如有些连接需要重用，都由这个类来管理的。这个类跟Dispatcher类一样，后续会详细的介绍这个类。
最后就是调用Builder的build方法来真正创建OkHttpClient对象。
(2). Request的创建
Request的创建方式跟 OkHttpClient都是通过Builder方法来创建的，在创建Request的对象时，我们会初始化很多东西，比如请求方式(get或者post)、请求的URL等等。这里就不详细的分析了。
(3).Call的创建
我们调用OkHttpClient的newCall方法来创建一个Call对象，我们来看看Call对象的创建过程。
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
Call是一个接口，它的唯一实现类是RealCall类，所以我们可以看到在Call方法里面又调用了RealCall的newRealCall方法。
我们来看看在RealCall的newRealCall方法里面进行哪些操作：
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;
}
private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
this.client = client;
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
}
归根结底，还是将我们创建好的OkHttpClient对象和Request对象传递到RealCall方法里面了。
(4).调用Call的execute方法
同步请求的最后一步操作就是调用Call的execute方法，我们来看看整个execute方法时怎么执行的。
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} catch (IOException e) {
eventListener.callFailed(this, e);
throw e;
} finally {
client.dispatcher().finished(this);
}
}
我们来重点分析几个点。首先：
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
从这里看的出来，每一个Call只能被执行一次，当第二次调用时，会抛出IllegalStateException异常。
然后就是这一对：
client.dispatcher().executed(this);
client.dispatcher().finished(this);
在正式进行网络请求之前，会调用Dispatcher的executed方法来将一个Call对象放在一个队列；在正式进行网络请求之后，会调用Dispatcher的finished方法将这个Call对象从队列中移除。
但是，这里，我们没有看到网络请求的步骤啊？究竟是哪一步进行了网络请求呢？没错，就是这一步。
Response result = getResponseWithInterceptorChain();
getResponseWithInterceptorChain方法通过调用拦截器链的每一个拦截器的proceed方法，最终返回Response对象，就是我们请求的数据。拦截器部分，在本篇文章不进行解释，后续会单独解释OkHttp的拦截器。
这就是，整个同步请求的执行过程，是不是非常的简单呢？接下来，我们来看看异步请求的。
2. 异步请求
异步请求的准备工作跟同步请求差不多，都是先创建OkHttpClient对象、然后创建Request对象，再创建Call对象，最后调用相应的方法来执行执行这个请求，异步请求调用的是enqueue方法。我们来看看enqueue方法：
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
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);
}
}
首先，先判断当前异步请求的数目是否超过我们设置的值，这里默认值是64，其次在判断当前的请求的主机是否超过了5个，都不超过的话，那么就将当前的Call添加到异步队列中，然后将当前的Call对象提交到线程池中去执行；如果超过的话，那么就将当前的Call对象放入等待队列中去。
我们知道，在同步请求中，是通过调用getResponseWithInterceptorChain方法来进行网络请求的，但是在这个异步请求过程中，我们并没有发现getResponseWithInterceptorChain方法的调用，难道是我们分析错了吗？并没有，我们需要在AsyncCall里面来寻找答案。
我们先来看看AsyncCall的结构：
final class AsyncCall extends NamedRunnable {
}
AsyncCall是继承于NamedRunnable的，我们再去看看NamedRunnable:
public abstract class NamedRunnable implements Runnable {
protected final String name;
public NamedRunnable(String format, Object... args) {
this.name = Util.format(format, args);
}
@Override public final void run() {
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute();
} finally {
Thread.currentThread().setName(oldName);
}
}
protected abstract void execute();
}
在NamedRunnable中，我们发现在run方法中调用了execute方法，最后我们回到了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 {
eventListener.callFailed(RealCall.this, e);
responseCallback.onFailure(RealCall.this, e);
}
} finally {
client.dispatcher().finished(this);
}
}
}
还是熟悉的味道，跟同步请求的差不多。但是这里我们需要注意的是，从这里可以看出，Callback的onFailure方法和onResponse方法都是在子线程中执行的，并没有通过Handler将消息传递到主线程。这里需要特别注意。
3.总结
OkHttp两种请求方式的执行流程是比较简单，现在对它做一个简单的总结。
1.同步请求和异步请求的在执行，都必须做同样的步骤来准备。包括OkHttpClient的创建，Request的创建，Call的创建。
2.同步请求是调用execute方法来执行，在execute方法中，通过调用getResponseWithInterceptorChain方法来真正进行网络请求，同时每一个Call只能执行一次。
3.异步请求是通过调用enqueue方法,最后提交到一个线程里面执行的。这里需要的注意的是Callback的onFailure方法和onResponse方法都是在子线程执行的。
