如果直到今天还有人跟你说，不要用那些什么开源框架，比如okhttp，不好，我们要自己写！
你可以反手就是一巴掌给他，因为okhttp在很久之前已经被谷歌收录，谷歌已经参照这个库的写法修改了对应的底层封装，虽然咱们依然用的是httpurlconnection，但其实内部实现已经被修改过了。所以简单来讲，okhttp就等于源码，下次再有人说这种不负责的话你就往死里打！
好了，我们回到正题，okhttp是一个什么鬼东西我就不具体说了，我打算把底层略浅的过一遍，一来增加自己的印象，二来各位看官也可以给自己过一遍印象，我觉得看源码就应该只抓重点，不然你会迷失在这片海洋里，人家一个团队辛辛苦苦写了那么久的东西，你一个人怎么可能那么快能够全盘掌握呢对吧。
估计一篇文章是不够分析的，所以我打算分为两篇或三篇来解析，那么话不多说，开始我们的第一篇。
首先我们上个使用方式，然后我们从使用方式开始入手一步步了解。
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.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 {
}
});
首先，enqueue是异步调用的方式，同步调用是用execute，他们的底层就前面有一些不一样，后面都一样，所以直接讲异步的就行。那我们先看看newCall，点进去（其实不看都可以猜到他是new一个call啦~）
@Override public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
继续跳
RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
this.client = client;
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
}
对吧，返回了一个RealCall实例，保存了一些参数，那么回到外面，我们看看call.enqueue()
void enqueue(Callback responseCallback);
咦，没看到实现，因为RealCall才是Call的实现类，那咱们应该去那边看，过去查一下
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
诶，找到了。来，开始一步步深入了，这里我们先去看看client.dispatcher()
public Dispatcher dispatcher() {
return dispatcher;
}
下面是这个类的开头，有一个线索点
public final class Dispatcher {
private int maxRequests = 64;
private int maxRequestsPerHost = 5;
private Runnable idleCallback;
/** Executes calls. Created lazily. */
private ExecutorService executorService;
...
看到ExecutorService了，其实Dispatcher就是一个线程分发器，用来处理请求线程的，利用线程池类去维护。那我们继续，回到上面去看看dispatcher().enqueue()
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
首先把自己添加进了队列，然后调用了线程池的execute方法，ok完成它的使命了，那咱们继续回到前面，看看最后的enqueue(new AsyncCall(responseCallback))的AsyncCall是个什么鬼
final class AsyncCall extends NamedRunnable {
窝，是个线程（这TM不是废话吗！），那我们来找找它的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() {
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute();
} finally {
Thread.currentThread().setName(oldName);
}
}
protected abstract void execute();
}
在这里了，调用了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);
}
}
兄弟们，execute()这个方法名是不是有点熟悉？
对的，如果我们一开始用同步，那么会直接跑到这里来。
所以说这两个方法后面从这里开始都是一样的了，前面就是上面讲的那些不一样，多了个线程池。
好，接下来要深入的是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);
}
要开始继续深入了，可以这样讲，okhttp的核心之一就是这一堆的拦截器。但是咱们先刹个车，先来回顾一下刚刚走的流程：
1，我们使用okHttpClient.newCall实例出了Call的实现类
2，我们调用了它的异步方法 ，里面重点是client.dispatcher().enqueue(new AsyncCall(responseCallback))
3，其中Dispatcher是这里面的分发器，它内部使用了ExecutorService线程池，然后将我们的AsyncCall添加了进去
4，我们的AsyncCall实现了Runnable，在run方法里执行了execute()，这也是一开始调用同步方法后走的地方
5，execute()方法注册了一系列拦截器，并组成了责任链（划重点，责任链设计模式，Okhttp的核心）
ok，这一篇先到这过，下一篇咱们从责任链这里开始。
Android-OKHttp底层原理浅析（二）
网友评论