return new RealCall(this, request, false /* for web socket */);
}
可以看到 call 对象实际是 RealCall 的实例化对象
RealCall#execute()
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException(“Already Executed”);
executed = true;
}
captureCallStackTrace();
try {
// 执行 client.dispatcher() 的 executed 方法
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException(“Canceled”);
return result;
} finally {
// 最后再执行 dispatcher 的 finish 方法
client.dispatcher().finished(this);
}
}
在 execute 方法中,首先会调用 client.dispatcher().executed(this)
加入到 runningAsyncCalls 队列当中,接着执行 getResponseWithInterceptorChain()
获取请求结果,最终再执行 client.dispatcher().finished(this)
将 realCall 从 runningAsyncCalls 队列中移除 。
我们先来看一下 getResponseWithInterceptorChain
方法
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List 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);
}
可以看到,首先,他会将客户端的 interceptors 添加到 list 当中,接着,再添加 okhhttp 里面的 interceptor,然后构建了一个 RealInterceptorChain
对象,并将我们的 List<Interceptor>
作为成员变量,最后调用 RealInterceptorChain 的 proced 方法。
-
client.interceptors() -> 我们自己添加的请求拦截器,通常是做一些添加统一的token之类操作
-
retryAndFollowUpInterceptor -> 主要负责错误重试和请求重定向
-
BridgeInterceptor -> 负责添加网络请求相关的必要的一些请求头,比如Content-Type、Content-Length、Transfer-Encoding、User-Agent等等
-
CacheInterceptor -> 负责处理缓存相关操作
-
ConnectInterceptor -> 负责与服务器进行连接的操作
-
networkInterceptors -> 同样是我们可以添加的拦截器的一种,它与client.interceptors() 不同的是二者拦截的位置不一样。
-
CallServerInterceptor -> 在这个拦截器中才会进行真实的网络请求
Interceptor 里面是怎样实现的,这里我们暂不讨论,接下来,我们来看一下 proceed 方法
proceed 方法
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
Connection connection) throws IOException {
// 省略无关代码
// 生成 list 当中下一个 interceptot 的 chain 对象
RealInterceptorChain next = new RealInterceptorChain(
interceptors, streamAllocation, httpCodec, connection, index + 1, request);
// 当前的 interceptor
Interceptor interceptor = interceptors.get(index);
// 当前的 intercept 处理下一个 intercept 包装的 chain 对象
Response response = interceptor.intercept(next);
// ----
return response;
}
proceed 方法也很简单,proceed方法每次从拦截器列表中取出拦截器,并调用 interceptor.intercept(next)。
熟悉 Okhttp 的应该都在回到,我们在 addInterceptor 创建 Interceptor 实例,最终都会调用 chain.proceed(Request request)
,从而形成一种链式调用。关于责任链模式的可以看我的这一篇文章 责任链模式以及在 Android 中的应用
OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Request.Builder builder = request.newBuilder().addHeader(“name”,“test”);
return chain.proceed(builder.build());
}
}).build();
而 OkHttp 是怎样结束循环调用的,这是因为最后一个拦截器 CallServerInterceptor 并没有调用chain.proceed(request),所以能够结束循环调用。
public final class Dispatcher {
private int maxRequests = 64;
private int maxRequestsPerHost = 5;
private Runnable idleCallback;
/** Executes calls. Created lazily. */
private ExecutorService executorService;
// 异步的请求等待队列
private final Deque readyAsyncCalls = new ArrayDeque<>();
// 异步的正在请求的队列
private final Deque runningAsyncCalls = new ArrayDeque<>();
// 绒布的正在请求的队列
private final Deque runningSyncCalls = new ArrayDeque<>();
}
异步请求 enqueue(Callback responseCallback)
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException(“Already Executed”);
executed = true;
}
captureCallStackTrace();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
首先,我们先来看一下 AsyncCall 这个类
final class AsyncCall extends NamedRunnable {
private final Callback responseCallback;
// ----
@Override protected void execute() {
boolean signalledCallback = false;
try {
Response response = getResponseWithInterceptorChain();
// 判断请求是否取消了,如果取消了,直接回调 onFailure
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);
}
}
}
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();
}
可以看到 AsyncCall 继承 NamedRunnable, 而 NamedRunnable 是 Runnable 的子类,当执行 run 方法时,会执行 execute 方法。
我们再来看一下 dispatcher 的 enqueue 方法
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
可以看到当正在请求的请求数小于 maxRequests
的时候并且当前正在请求的队列里面相当 host 的小于 maxRequestsPerHost
, 直接添加到 runningAsyncCalls
队列中,并添加到线程池里面执行,否则添加到准备队列 readyAsyncCalls
里面。
当执行 executorService().execute(call)
的时候,会调用 run 方法, run 方法又会调用到 execute 方法进行网络请求,请求完成之后,会调用 client.dispatcher().finished(this)
从队列里面移除。
到此, Okhttp 的主要流程已经讲完
- 有一个分发器 Dispatcher,里面有三个请求队列,一个是正在请求的队列,一个是等待队列,另外一个是同步的正在请求的队列,当我们执行 enqueue 方法的时候,他会判断正在请求队列数量是否超过允许的最大并发数量(默认是 64)(线程池的原理),如果超过了,会添加到等待队列里面。
excute 方法是同步执行的,每次执行会添加到同步请求队列当中,执行完毕之后会移除
-
设计的核心思想责任链模式,当我们需要拦截的时候,可以实现 Interceptor 接口,会按照添加的顺序执行 Chain.proceed 方法。
-
职责分明,OkhttpClient 对象主要处理一些基础的配置,比如连接超时,读写超时,添加拦截器。Request 主要配置请求方法,请求头等。
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此我收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
*。
因此我收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-5AWk4zbD-1715808439963)]
[外链图片转存中…(img-R9a48V6r-1715808439964)]
[外链图片转存中…(img-Ikc9dHJf-1715808439965)]
[外链图片转存中…(img-nSHogc95-1715808439966)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点!不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!