OKHttp源码分析
OkHttp是个目前比较流行的网络请求框架，现在大部分的应用都有在用它，看了很多大佬们写的OKHttp相关的博客，在这里记录下自己的分析过程。由于OkHttp内容比较多，这篇文章主要先简单分析下OkHttp请求的基本流程。
首先，在分析源码之前先看下使用OkHttp请求的示例代码：
val okHttpClient = OkHttpClient.Builder()
.readTimeout(15, TimeUnit.SECONDS)
.connectTimeout(10, TimeUnit.SECONDS)
.build()
val request = Request.Builder()
.url("https://blog.csdn.net/qq_21612413/article/details/87358000")
.build()
val call = okHttpClient.newCall(request)
// 同步请求
// val response = call.execute()
// 异步请求
call.enqueue(object : Callback {
override fun onFailure(call: Call, e: IOException) {
println("failure")
}
override fun onResponse(call: Call, response: Response) {
println("response：${response.body()?.string()}")
}
})
可以看到，基本流程是先构建OkHttpClient和Request实例，然后通过调用newCall方法，传入request对象获得一个Call对象，通过这个Call对象来发起同步或异步请求。
OkHttp分析
- 1、获取OkHttpClient实例
- 1.1、默认构造
- 1.2、使用Builder模式构建
- 2、Request对象的构建
- 3、请求流程分析
- 3.1、异步请求
- 3.2、同步请求
- 3.3、拦截器处理返回Response
- 总结
1、获取OkHttpClient实例
通过有两个方式来获取OkHttpClient实例，一种是默认的构造方法，另一种是使用Builder模式来构建对象。
1.1、默认构造
val okHttpClient = OkHttpClient()
其内部构造函数使用了Builder对象，使用的都是默认配置：
public OkHttpClient() {
this(new Builder());
}
public Builder() {
dispatcher = new Dispatcher();
protocols = DEFAULT_PROTOCOLS;
connectionSpecs = DEFAULT_CONNECTION_SPECS;
eventListenerFactory = EventListener.factory(EventListener.NONE);
... 省略
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
1.2、使用Builder模式构建
val okHttpClient = OkHttpClient.Builder()
.readTimeout(15, TimeUnit.SECONDS)
.connectTimeout(10, TimeUnit.SECONDS)
.build()
可使用OkHttpClient.Builder类配置参数，最后调用build方法返回一个OkHttpClient对象。
public OkHttpClient build() {
return new OkHttpClient(this);
}
2、Request对象的构建
val request = Request.Builder()
.url("https://blog.csdn.net/qq_21612413/article/details/87358000")
.build()
构建了一个OkHttpClient对象之后，我们还需要构建一个Request对象，通过查看它的构造函数可以看到，它也需要通过Builder模式来构建。
public static class Builder {
@Nullable
HttpUrl url;
String method;
Headers.Builder headers;
RequestBody body;
public Builder() {
this.method = "GET";
this.headers = new Headers.Builder();
}
Builder(Request request) {
this.url = request.url;
this.method = request.method;
this.body = request.body;
this.tags = request.tags.isEmpty()
? Collections.emptyMap()
: new LinkedHashMap<>(request.tags);
this.headers = request.headers.newBuilder();
}
public Request build() {
if (url == null) throw new IllegalStateException("url == null");
return new Request(this);
}
}
Request(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = builder.headers.build();
this.body = builder.body;
this.tags = Util.immutableMap(builder.tags);
}
3、请求流程分析
val call = okHttpClient.newCall(request)
val response = call.execute()
通过newCall方法获取到Call对象后，再执行同步或异步请求，先看下newCall方法的内部实现：
public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
RealCall类:
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
RealCall call = new RealCall(client, originalRequest, forWebSocket);
call.eventListener = client.eventListenerFactory().create(call);
return call;
}
可以看到，Call对象实际是RealCall类型。
3.1、异步请求
执行Call的enqueue方法：
public void enqueue(Callback responseCallback) {
// 判断是否已执行，如果已执行，则抛出异常
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
// 捕获并设置堆栈信息日志
captureCallStackTrace();
eventListener.callStart(this);
// 执行Dispatcher的enqueue方法
// AsyncCall对象，该对象继承NamedRunnable
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
可以看到，enqueue方法不能被重复执行，否则会抛出IllegalStateException异常，该方法最后会执行Dispatcher的enqueue方法，传入了一个AsyncCall对象：
void enqueue(AsyncCall call) {
synchronized (this) {
// 将请求放入异步准备队列
readyAsyncCalls.add(call);
}
promoteAndExecute();
}
private boolean promoteAndExecute() {
assert (!Thread.holdsLock(this));
List<AsyncCall> executableCalls = new ArrayList<>();
boolean isRunning;
synchronized (this) {
// 遍历异步准备队列
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
// 取出Call对象
AsyncCall asyncCall = i.next();
// 判断异步Running队列的数量是否小于最大请求数量（默认为64）
if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
// 判断请求同一主机的个数是否小于maxRequestsPerHost（最大可请求主机个数，默认是5）
if (runningCallsForHost(asyncCall) >= maxRequestsPerHost)
continue; // Host max capacity.
// 将Call对象移出异步准备队列
i.remove();
// 添加到执行集合
executableCalls.add(asyncCall);
// 添加到异步Running队列
runningAsyncCalls.add(asyncCall);
}
isRunning = runningCallsCount() > 0;
}
// 遍历待执行集合
for (int i = 0, size = executableCalls.size(); i < size; i++) {
AsyncCall asyncCall = executableCalls.get(i);
// 调用Call对象的executeOn方法
// executorService返回一个线程池对象
asyncCall.executeOn(executorService());
}
return isRunning;
}
该方法的作用主要是把任务放入readyAsyncCalls（异步准备队列），然后再遍历该队列判断任务是否可以被执行，如果可以，则将任务放入一个待执行对象集合中，最后遍历待执行对象集合将任务逐个放入线程池中执行，接下来看下AsyncCall的executeOn方法（传入的参数是个线程池对象）：
void executeOn(ExecutorService executorService) {
assert (!Thread.holdsLock(client.dispatcher()));
boolean success = false;
try {
// 放入线程池中执行，AsyncCall继承了NamedRunnable对象，NamedRunnable的run方法执行了execute方法
executorService.execute(this);
success = true;
} catch (RejectedExecutionException e) {
InterruptedIOException ioException = new InterruptedIOException("executor rejected");
ioException.initCause(e);
eventListener.callFailed(RealCall.this, ioException);
responseCallback.onFailure(RealCall.this, ioException);
} finally {
if (!success) {
client.dispatcher().finished(this); // This call is no longer running!
}
}
}
可以看到，由于AsyncCall继承自NamedRunnable类（实现了Runnable 接口），所以executorService.execute(this)会去执行NamedRunnable的run方法：
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() {
// 在执行之前把当前线程的名字改为由构造生成的name，执行完execute方法后再把线程名字改回去
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute(); // 执行
} finally {
Thread.currentThread().setName(oldName);
}
}
protected abstract void execute();
}
最后执行了execute方法：
protected void execute() {
boolean signalledCallback = false;
timeout.enter();
try {
// 调用拦截器，最终返回Response对象
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) {
e = timeoutExit(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);
}
}
在execute方法中，会通过getResponseWithInterceptorChain方法（拦截器处理）返回Response对象，如果请求被取消了，则返回onFailure失败回调，否则，返回onResponse成功回调。这里需要注意的是，请求被取消，会回调到onFailure方法。接下来我们再来看下同步请求的流程：
3.2、同步请求
public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
// 堆栈信息跟踪
captureCallStackTrace();
timeout.enter();
eventListener.callStart(this);
try {
// 调用Dispatcher的executed方法，将Call对象添加进同步运行队列中
client.dispatcher().executed(this);
// 经过各种拦截器处理后最终返回Response对象
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);
}
}
// Dispatcher的executed方法
synchronized void executed(RealCall call) {
this.runningSyncCalls.add(call);
}
同步请求相对简单，在该方法中把Call对象放入了runningSyncCalls（同步运行队列）中，最终也调用getResponseWithInterceptorChain方法返回Response对象。
3.3、拦截器处理返回Response
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
// 构建个拦截器的集合
List<Interceptor> interceptors = new ArrayList<>();
// 添加自定义的拦截器
interceptors.addAll(client.interceptors());
// 添加错误处理和重定向拦截器
interceptors.add(retryAndFollowUpInterceptor);
// 封装request和response过滤器
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));
// 构建RealInterceptorChain，传入拦截器集合，request对象等，注意index为0这个参数
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
// 调用proceed方法
return chain.proceed(originalRequest);
}
构建了个拦截器的集合，将它传入RealInterceptorChain对象，通过该对象来完成拦截器的链式调用。
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
// 如果index大于或等于拦截器集合个数，则抛出异常
if (index >= interceptors.size()) throw new AssertionError();
calls++;
// If we already have a stream, confirm that the incoming request will use it.
if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must retain the same host and port");
}
// If we already have a stream, confirm that this is the only call to chain.proceed().
if (this.httpCodec != null && calls > 1) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must call proceed() exactly once");
}
// Call the next interceptor in the chain.
// 构建一个next的RealInterceptorChain，index+1
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
// 取出拦截器
Interceptor interceptor = interceptors.get(index);
// 调用拦截器的intercept方法，传入next对象，拿个拦截器看下里面具体的实现是怎样的
Response response = interceptor.intercept(next);
// Confirm that the next interceptor made its required call to chain.proceed().
if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
throw new IllegalStateException("network interceptor " + interceptor
+ " must call proceed() exactly once");
}
// Confirm that the intercepted response isn't null.
if (response == null) {
throw new NullPointerException("interceptor " + interceptor + " returned null");
}
if (response.body() == null) {
throw new IllegalStateException(
"interceptor " + interceptor + " returned a response with no body");
}
return response;
}
注意index这个参数，默认传入是为0，当构建一个next的RealInterceptorChain时，此时index+1了。执行流程是当前拦截器链会根据index取出对应位置的拦截器，调用拦截器的intercept方法，传入next对象。接着在拦截器中又会调用next对象的proceed方法，重新进入这个方法，然后又调用下一个拦截器的intercept方法（此时index+1），形成链式调用，直到最后一个拦截器（CallServerInterceptor）不调用next对象的proceed方法为止，最后逐级返回response对象。
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
//1 Request阶段，该拦截器在Request阶段负责做的事情
//2 调用RealInterceptorChain.proceed()，其实是在递归调用下一个拦截器的intercept()方法
response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);
//3 Response阶段，完成了该拦截器在Response阶段负责做的事情，然后返回到上一层的拦截器。
return response;
}
}
用下图来表示拦截器的执行流程：
总结
这篇文章主要分析了下OKHttp的基本流程，还有很多细节还没有分析，例如拦截器等，在对整体有了清晰认识之后，再单独进行深入分析理解起来会相对简单点。最后用一张图（图来源于拆轮子系列：拆 OkHttp，感谢作者）来回顾下基本的请求流程：
