我们在前面几个章节的学习过程中,已经可以明白OkHttp的基本使用,OkHttp在使用的过程中几个常用的类的分析,OkHttp的分配器Dispatcher。其中在RealCall中,不管是同步请求还是异步请求,最终都会调用的一个方法,得到网络请求响应结果Response,就是getResponseWithInterceptorChain()方法。因为这个方法用的是拦截器链调用拦截器执行对应的方法,所以我们决定放到现在来讲,我们先看一下getResponseWithInterceptorChain()的调用位置:
//同步请求获取请求结果
@Override public Response execute() throws IOException {
...
try {
...
Response result = getResponseWithInterceptorChain();//获取请求结果
...
return result;
} catch (IOException e) {
...
} finally {
...
}
}
上面我们看到的,是我们调用Call的同步请求方法execute()时,的部分代码,可以看到,在该方法中真正获取请求结果的只有一句代码Response result = getResponseWithInterceptorChain(),就是说,同步请求会直接调用getResponseWithInterceptorChain()方法,获取Response并返回个调用者。
我们再看异步请求是如何调用的getResponseWithInterceptorChain()方法,首先我们异步请求调用的是Call的enqueue(Callback)方法:
//Call的异步请求方法,请求结果会利用Callback接口回调返回给调用者
@Override public void enqueue(Callback responseCallback) {
...
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
通过部分代码,我们看到,Call的enqueue(Callback)方法,会调用Dispatcher的enqueue(AsyncCall)方法,我们继续看一下Dispatcher的enqueue(AsyncCall)方法:
//Dispatcher的异步请求方法,被Call调用。Asyncall是异步请求任务
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);//线程池执行异步任务,最终会执行AsyncCall的execute()方法
} else {
readyAsyncCalls.add(call);
}
}
上面的代码我们前面已经讲过多次,executorService().execute(call)使用线程池异步执行了异步请求任务,其中的请求任务代码,在AsyncCall类的execute()方法中,相当于在异步线程中执行了AsyncCall类的execute()方法,所以我们在跳转到AsyncCall类中,查看一下它的execute()方法:
//RealCall的内部类AsyncCall,用来做异步请求任务,是Runnable的子类。
@Override protected void execute() {
...
try {
//获取请求结果
Response response = getResponseWithInterceptorChain();
if (...) {
...//判断,使用Callback接口回调返回给调用者
responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
} else {
...//判断,使用Callback接口回调返回给调用者
responseCallback.onResponse(RealCall.this, response);
}
} catch (IOException e) {
if (signalledCallback) {
...
} else {
...//判断,使用Callback接口回调返回给调用者
responseCallback.onFailure(RealCall.this, e);
}
} finally {
...
}
}
上面代码,相信大家都能看懂,在AsyncCall的execute()方法中调用了getResponseWithInterceptorChain()方法。获取到了请求结果,然后经过判断,在利用调用者传进来的Callback接口,做接口回调,将结果回传给调用者,完成了异步请求。
前面说了这么多,就是为了说明不管是同步请求还是异步请求,都会调用RealCall中的getResponseWithInterceptorChain()来获取请求结果Response,所以我们现在将getResponseWithInterceptorChain()代码放上来,分析一下:
//RealCall的同步、异步请求都会调用此方法,这是获取网络请求结果Response的关键方法
Response getResponseWithInterceptorChain() throws IOException {
//创建一个存储拦截器的集合
List interceptors = new ArrayList<>();
//将用户传入的Application拦截器添加到集合中
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) {//如果不是WebSocket连接
//将用户传入的Network拦截器加入的
interceptors.addAll(client.networkInterceptors());
}
//将CallServer拦截器(与服务器进行数据交互)加入到集合中
interceptors.add(new CallServerInterceptor(forWebSocket));
//创建拦截器链,index初始值为0
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
//调用拦截器链的proceed方法,就会调用到所有拦截器,并返回请求结果Response
return chain.proceed(originalRequest);
}
这一节,我们先不讲代码中提到的每个拦截器的作用,我们只讲拦截器的调用。我们从上面代码中可以看到,首先会将各种拦截器按照先后顺序,分别加入到新创建的ArryList集合中,然后创建了Interceptor.Chain拦截器链实例,在创建过程中,构造函数传入了存有各种拦截器的集合interceptors、数字0、用户创建好的Request对象、当前RealCall对象、OkHttp网络请求详细事件回调接口、超时设置。最后,调用了拦截器链chain的proceed(Request)方法,该方法返回Response正是调用者需要的服务器端的响应结果。我们先大概知道一下,这个方法中,主要做了些什么工作。接下来我们来看拦截器链。
首先我们通过代码查找,看到Interceptor.Chain是一个interface,它的目前唯一实现类就是RealInterceptorChain,我们看下这个类的构造方法
//RealInterceptorChain构造方法
public RealInterceptorChain(List interceptors, StreamAllocation streamAllocation,
HttpCodec httpCodec, RealConnection connection, int index, Request request, Call call,
EventListener eventListener, int connectTimeout, int readTimeout, int writeTimeout) {
this.interceptors = interceptors;//RealCall那边创建好并且已经添加好了所有拦截器
this.connection = connection;//null
this.streamAllocation = streamAllocation;//null
this.httpCodec = httpCodec;//null
this.index = index;//RealCall传入的是0
this.request = request;//用户构建好的Request
this.call = call;//当前RealCall
this.eventListener = eventListener;
this.connectTimeout = connectTimeout;
this.readTimeout = readTimeout;
this.writeTimeout = writeTimeout;
}
我们需要注意一点,他的变量index正是我们刚才RealCall的getResponseWithInterceptorChain()方法中传入的0,我们接着看一下我们前面调用的RealInterceptorChain的proceed(Request)方法:
//首次调用拦截器链
@Override public Response proceed(Request request) throws IOException {
return proceed(request, streamAllocation, httpCodec, connection);
}
//继续调用拦截器链,将获取到的Response返回去
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
...
//这里需要注意,创建的拦截器链RealInterceptorChain,传入的参数中(index+1)
RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
writeTimeout);
//这里需要注意,获取到的拦截器是角标为index的拦截器,而index正是通过其构造函数赋值的
Interceptor interceptor = interceptors.get(index);
//调用拦截器的intercept()方法获取Response
Response response = interceptor.intercept(next);
...
return response;//将请求结果返回
}
讲到这里,可能很多人还是有些懵懵懂懂,我来帮大家捋一下:
1、在RealCall的getResponseWithInterceptorChain()方法中,我们第一次创建了拦截器链对象RealInterceptorChain,将存有拦截器的集合interceptors传给了RealInterceptorChain,同时设置了它的index为0,紧接着调用了RealInterceptorChain的proceed方法;
2、在RealInterceptorChain的proceed方法中,再次创建了RealInterceptorChain的实例,继续将存有拦截器的集合interceptors传递给新创建的RealInterceptorChain,这时给他设置的index为当前index+1,然后从interceptors中获取角标为当前index的Interceptor,执行Interceptor的intercept(Chain)方法,参数Chain就是新创建的index+1的RealInterceptorChain对象,并将获取到的Response返回给上一个调用者;
3、Interceptor本身是interface,其intercept(Chain)方法具体看它的实现类,可以肯定的一点是,intercept(Chain)方法中,除了做拦截器本身该做的一些操作外,会继续调用Chain的proceed方法,进入Chain的proceed方法中继续创建index+1的Chain,并且获取角标为index的Interceptor,调用它的intercept(Chain)方法......一直调用下去,直到最后一个拦截器为止。
上面我说捋一下,我想还有人不太明白,因为到现在为止,还缺少一部分代码,那就是Interceptor的intercept(Chain)方法究竟是怎么样子的,我们先看下Interceptor接口的类继承情况
其中LoggingInterceptor是我自己创建的继承自Interceptor,其他五个都是OkHttp框架已经提供的拦截器,我们在刚才讲getResponseWithInterceptorChain()方法时候,都见过的,先不纠结每一个拦截器的作用。我们主要是为了研究一下这些拦截器的intercept(Chain)方法。getResponseWithInterceptorChain()方法创建了存储拦截器的ArrayList集合,并且将拦截器都存入了该集合,我们刚才提到,会根据顺序,每次index+1来获取interceptors中的Interceptor,并调用其intercept(Chain)方法。我们取两个具有代表性的进行研究,这五个拦截器中,按照添加顺序排在最前面的RetryAndFollowUpInterceptor和排在最后的CallServerInterceptor,分别看一下他们的intercept(Chain)方法
RetryAndFollowUpInterceptor的intercept(Chain)方法
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
RealInterceptorChain realChain = (RealInterceptorChain) chain;
...
StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
createAddress(request.url()), call, eventListener, callStackTrace);
...
while (true) {
...//此处调用了拦截器链RealInterceptorChain的proceed方法
response = realChain.proceed(request, streamAllocation, null, null);
...
return response;
...
}
}
我们可以发现,在RetryAndFollowUpInterceptor的intercept(Chain)方法中,的确调用了拦截器链RealInterceptorChain的proceed()方法,这样就可以继续往下,调用下一个Interceptor的intercept(Chain)方法,一直调用下去,直到最后一个拦截器CallServerInterceptor结束。
CallServerInterceptor的intercept(Chain)
//这是CallServerInterceptor的intercept(Chain)方法,该方法不会调用Chain的proceed方法
@Override public Response intercept(Chain chain) throws IOException {
...
Response response = responseBuilder
.request(request)
.handshake(streamAllocation.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
...
return response;
}
通过仔细阅读该代码,发现CallServerInterceptor果然没有继续调用Chain的proceed方法。拦截器链Chain的proceed方法,第一次调用,是被RealCall类的getResponseWithInterceptorChain()方法,然后proceed获取角标为index的Interceptor,调用Interceptor的intercept(Chain)方法,index+1,intercept(Chain)方法继续调用下一个RealInterceptorChain的proceed方法,一直这样调用下去,直到最后一个拦截器,这就是拦截器链的调用。
我们先通过两幅幅图来描述拦截器链的工作
我们来简单的总结一下本章要跟大家分享的:
1、OkHttp的网络请求,其本质上是由拦截器链的调用完成的;
2、拦截器链的调用,起始于RealCall的getResponseWithInterceptorChain方法,结束与最后一个拦截器CallServerInterceptor的intercept(Chain)方法;
3、连接器链的调用,RealInterceptorChain的作用是按照顺序依次调用每一个拦截器的intercept(Chain)方法。拦截器Interceptor的作用是发挥自身拦截器的特性,对Request和Response做出操作,调用RealInterceptorChain的proceed()方法,让其继续下去;
4、我们可以将拦截器的调用看作递归,逐层向下调用,直到最后一个拦截器返回Response,然后在逐层向上,一边处理Response一边返回给上一层,最终返回给调用。
本章节关于拦截器链的讲解到此结束了,拦截器是OkHttp框架的精髓,所以我们会拿出几篇文章来详细分析,下一章节开始我们将分析每一个拦截器。