我们先来看下OkHttp的两个使用方法
同步：
//同步执行方法，不应该在UI线程使用
response = client.newCall(request).execute();
//异步方法
response = client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
}
});
让我们进入newCall一探究竟~
/**
* Prepares the {@code request} to be executed at some * point in the future.
*/
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
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对象，接下来继续看RealCall是个什么东西，主要看他的 execute和enqueue方法
@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);
}
}
}
由此可见execute确实是执行在调用它的线程里面的，看代码应该是通过getResponseWithInterceptorChain()来具体执行的，看到了似曾相识的interceptor，其实这里是运用了责任链设计模式的拦截器，这个稍后再说 execute方法暂时先告一段落，接下来看enqueue
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
//看来这里才是真正执行的方法，继续跟踪，发现了一个dispather，并且还new了一个AsyncCall对象，传入了我们的匿名内部类接口实例
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
上面跟踪到了一个dispather，这个又是个什么鬼？字面理解是分发器，看来事情没有这么简单啊，继续跟进
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
//咦，这个不是线程池嘛
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
我们逮到了dispather的enqueue，发现他的call是丢给了线程池了，那么这个call，也就是AsyncCall是什么？先来看看它吧
/**
*注意这个类在RealCall类里面哦，是其内部类
*/
final class AsyncCall extends NamedRunnable {
private final Callback responseCallback;
AsyncCall(Callback responseCallback) {
super("OkHttp %s", redactedUrl());
this.responseCallback = responseCallback;
}
String host() {
return originalRequest.url().host();
}
Request request() {
return originalRequest;
}
RealCall get() {
return RealCall.this;
}
//发现AsyncCall也有一个execute方法，和RealCall差不多
@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;
//这个是传进来的回调啦，它不是UI线程
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);
//这个也是传进来的回调啦，它也不是UI线程
responseCallback.onFailure(RealCall.this, e);
}
} finally {
client.dispatcher().finished(this);
}
}
}
原来它实现了NamedRunnable，那么这个NamedRunnable应该是实现了Runnable，然后我们这个execute没有在这里被调用，猜想应该是被父类重写的run给调用了，然后这个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();
}
回到RealCall的enqueued来，是不是思路清晰多了。
首先，newCall(request)初始化request后生成了一个RealCall,紧接着RealCall的execute开始执行这个请求，如果异步，就是传入enqueue(callback)，然后调用dispather.enqueue(new AsyncCall(callback))，这个AsyncCall呢他是RealCall内部类所以同样可以访问到newCall(request)初始化后的request，它持有callback回调同时又是个Runnable,并且它的run方法调用了他自己和外部类RecalCall名称相同功能相似的execute方法，然后这个AsyncCall在dispather里面是丢给线程池执行的，这样一来问题就通了。
@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));
}
说了这么久dispather？这个dispather到底是啥？别急，继续看
private int maxRequests = 64;
private int maxRequestsPerHost = 5;
...
public Dispatcher(ExecutorService executorService) {
this.executorService = executorService;
}
public synchronized ExecutorService executorService() {
if (executorService == null) {
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
原来真是个线程池的封装类。。。这个线程池核心线程0，非核心线程int的最大值，但是外面maxRequest和 maxRequestsPerHost已经限制了它的并发线程数了，非核心线程60s超时时间，阻塞队列是SynchronousQueue，也就是不存储元素的队列，进了必出。到此问题已经基本解决。
下面说一下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, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
return chain.proceed(originalRequest);
}
继续看chain.proceed，看之前顺便提下责任链设计模式。典型的责任链模式，是定义一个责任链节点对象抽象类，定义一个消息抽象类，每个节点对象必须实现抽象类的handleMessage(Object message)方法，然后对传进来的消息按实际情况处理，未处理完或者不能处理的交给下一个链节点对象，直到消息处理完毕。
责任链体现了典型的分层思想，分层的好处是显而易见的，复杂简单化，灵活和易于维护。比如TCP/IP协议就是经典的例子。
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
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.
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
Interceptor interceptor = interceptors.get(index);
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;
}
简单总结下上面代码，其实大概就是getResponseWithInterceptorChain()里面先实例化一条责任链，注册各种拦截器(链节点对象)，然后通过chain.proceed获得下一个拦截器(节点)
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
Interceptor interceptor = interceptors.get(index);
每次调用chain对象proceed获得节点后,节点的intercept取出chain里面的request处理，然后用户在里面又调用procee,index+1，获得下一个拦截器，然后调用拦截器的拦截方法intercept，用户里面又取出chain里面的request处理，继续循环下去。
简要说下拦截器
- 应用拦截器(用户添加)
- 重定向等的拦截器
- 构造请求头的拦截器
- 缓存拦截器
- 连接拦截器
- 网络拦截器(用户添加)
- 数据传输拦截器
最后附上网络上的两个图总结
OkHttp流程
拦截器
最后
如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。谢谢。
希望读到这的您能转发分享和关注一下我，以后还会更新技术干货，谢谢您的支持！
转发+点赞+关注，第一时间获取最新知识点
Android架构师之路很漫长，一起共勉吧！
——————分割线——————
简书点赞可以有好几种赞，长按点赞按钮就会有选项，大家点赞的时候，麻烦点个超赞~
网友评论