执行一个request是调用它的enqueue并传递一个回调
mcall.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
System.out.println("onFailure---" + e);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (null != response.cacheResponse()) {
String str = response.cacheResponse().toString();
System.out.println("cache---" + str);
} else {
response.body().string();
String str = response.networkResponse().toString();
System.out.println("network---" + str);
}
}
});
有前面分析可知这里的mcall是RealCall
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
创建一个AsyncCall,调用dispatcher把前面创建的AsyncCall入队列
AsyncCall继承于NamedRunnable实现了Runnable接口
我们看下dispatcher的enque
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
如果请求总数小于max且当前连接请求数小于maxRequestPerHost,则添加到runningAsyncCalls,并调用executorService然后执行execute
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;
}
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 {
responseCallback.onFailure(RealCall.this, e);
}
} finally {
client.dispatcher().finished(this);
}
}
}
这里首先调用
getResponseWithInterceptorChain,getResponseWithInterceptorChain会通过一系列的拦截器实现网络请求逻辑,而异步则是通过前面的 ExecutorService
实现。然后根据返回的结果调用回调函数响应的接口,如成功则调用onResponse等
private 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 (!retryAndFollowUpInterceptor.isForWebSocket()) {
interceptors.addAll(client.networkInterceptors());
}
interceptors.add(new CallServerInterceptor(
retryAndFollowUpInterceptor.isForWebSocket()));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
这里主要是添加一系列的拦截器,首先添加的是我们设置的,然后分别添加如下拦截器:
interceptors:代码中添加的应用拦截器
RetryAndFollowUpInterceptor:负责失败重连以及重定向的
BridgeInterceptor:主要负责构造请求,如请求头,以及构造请求结果和处理如是否有gzip压缩等
CacheInterceptor:缓存处理,读取缓存,缓存更新等
ConnectInterceptor:负责和服务器建立连接
networkInterceptors:代码中设置的网络拦截器
CallServerInterceptor:负责跟服务器交互,发送请求,获取响应
RealInterceptorChain:负责执行上面的这些拦截器
应用拦截器和网络拦截器的特点
应用拦截器:主要用于查看请求信息及返回信息,如链接地址、头信息、参数信息等
*不必要担心响应和重定向之间的中间响应。
*通常只调用一次,即使HTTP响应是通过缓存提供的。
*遵从应用层的最初目的。与OkHttp的注入头部无关,如If-None-Match。
*允许短路而且不调用Chain.proceed()。
*允许重试和多次调用Chain.proceed()。
网络拦截器:可以添加、删除或替换请求头信息,还可以改变的请求携带的实体
*允许像重定向和重试一样操作中间响应。
*网络发生短路时不调用缓存响应。
*在数据被传递到网络时观察数据。
*有权获得装载请求的连接。
具体参考:
http://blog.csdn.net/oyangyujun/article/details/50039403
http://blog.csdn.net/tangxl2008008/article/details/51887285
他们的作用我们也可以从他们所出的层次可以看出来
接下来以一张图概括整个调用流程,后面在单独分析各个拦截器
代码最后把前面添加的拦截器以及原始的请求作为参数构造了一个RealInterceptorChain,index为0,然后调用它的proceed方法
@Override public Response proceed(Request request) throws IOException {
return proceed(request, streamAllocation, httpStream, connection);
}
public Response proceed(Request request, StreamAllocation streamAllocation, HttpStream httpStream,
Connection 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.httpStream != null && !sameConnection(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.httpStream != 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, httpStream, connection, index + 1, request);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
// Confirm that the next interceptor made its required call to chain.proceed().
if (httpStream != 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");
}
return response;
}
这里首先判断index是否大于拦截器个数,然后判断当前是否已经建立了一个http流,且是否请求路径一致
然后新建一个RealInterceptorChain传递index+1为参数,其他参数保持不变
最后获取当前index(0)出的拦截器,并调用它的intercept方法
这里获取到的拦截器就是RetryAndFollowUpInterceptor,下一篇我们看他都做了什么处理。