Okhttp 基础知识导图
Okhttp 使用
1，创建一个客户端。
2，创建一个请求。
3，发起请求(入参回调)。
Request request = new Request.Builder().url( "http://xxxxx").build();
//创建客户端
OkHttpClient mOkHttpClient= new OkHttpClient.Builder()
.connectTimeout(30000, TimeUnit.MICROSECONDS)
.readTimeout(30000, TimeUnit.MICROSECONDS)
.writeTimeout(30000, TimeUnit.MICROSECONDS).build();
//创建请求
Call mCall= mOkHttpClient.newCall(request);
//请求+回调
mCall.enqueue(new Callback() {
@Override
public void onFailure(Call arg0, IOException arg1) {
}
@Override
public void onResponse(Call arg0, Response arg1) throws IOException {
}
});
一、任务分发
网络请求不能占用主线程资源，在多个请求并发条件下，需要一个管理器实现任务分发，将任务交给线程池。
1，RealCall 类
Request 类是一个请求实体，配置 url，组装 Header，请求体RequestBody， method 支持 GET、HEAD、POST、DELETE、PUT、PATCH。
每个 Request 实体创建一个 RealCall 对象，负责一个具体请求的 http 事务。
@Override
public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
Call 接口，内部工厂 Call.Factory 的 newCall() 方法创建，OkHttpClient 类实现工厂接口，创建 RealCall。
RealCall 类同步方法。
@Override
public Response execute() throws IOException {
synchronized (this) {
...
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();//同步，耗时处
return result;
} finally {
client.dispatcher().finished(this);
}
}
异步方法。
@Override
public void enqueue(Callback responseCallback) {
synchronized (this) {
...
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
execute() 方法，同步请求需要自己实现线程池。enqueue() 方法，创建一个异步任务，交给分发者，Dispatcher 类分发，(同步或异步)。
2，Dispatcher 分发者
Dispatcher 类控制多个 http 请求的节奏，负责 RealCall 的并发，管理(等待/运行)队列，线程池调度。
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
同步分发，将 RealCall 对象加入同步队列，表示 RealCall 正在执行。
synchronized void enqueue(AsyncCall call) {
//maxRequests=64，maxRequestsPerHost=5
if (runningAsyncCalls.size() < maxRequests &&
runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);//加入运行队列
executorService().execute(call);//线程池执行任务
} else {
readyAsyncCalls.add(call);
}
}
异步分发，maxRequests：最大请求数量，maxRequestsPerHost：每个主机最大并发请求数量。
满足运行时，将 AsyncCall (Runnable 任务，RealCall 内部类)，加入运行队列，派发线程池处理，不满足运行时，加入等待队列。
3，请求结束
每次(同步/异步)请求完成时，在 try/finally() 方法结束，Dispatcher 类的 finished()方法。
private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
int runningCallsCount;
Runnable idleCallback;
synchronized (this) {
//同步队列删除RealCall，异步运行队列删除AsyncCall任务
if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
if (promoteCalls) promoteCalls();//异步promoteCalls参数是true
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}
if (runningCallsCount == 0 && idleCallback != null) {
idleCallback.run();
}
}
异步请求时，继续查询等待队列中的请求。
private void promoteCalls() {
if (runningAsyncCalls.size() >= maxRequests) return;
if (readyAsyncCalls.isEmpty()) return;
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall call = i.next();
if (runningCallsForHost(call) < maxRequestsPerHost) {
i.remove();//满足条件，等待队列删除
runningAsyncCalls.add(call);//加入运行中队列
executorService().execute(call);//开始执行
}
if (runningAsyncCalls.size() >= maxRequests) return;
}
}
遍历等待队列的任务，满足运行条件时，从等待队列删除，加入运行队列，派发线程池。
二、线程池管理
分发者内部阀值[0, Integer.MAX_VALUE]的缓存线程池。
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;
}
- 不保留 corePoolSize 核心线程，最大可创建线程 MAX_VALUE。
- 工作线程 keepAliveTime 设置60存活期线程复用。
- SynchronousQueue 阻塞队列不存储元素，管道。
大量http请求并发时，线程池启动多个工作线程(临时线程)，确保每个任务都有线程及时处理。
线程执行主体是 NamedRunnable 类 run() 方法，子类是运行队列中的 AsyncCall任务类，实现 execute() 抽象方法。
AsyncCall 构造方法，传入外部Callback回调对象。
@Override
protected void execute() {
boolean signalledCallback = false;
try {
//触发RealCall类的方法，AsyncCall任务类定义在RealCall类内部。
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) {
} finally {
//异步请求结束后finish。
client.dispatcher().finished(this);
}
}
外部 RealCall 类的 getResponseWithInterceptorChain() 方法，(同步/异步)请求耗时操作，返回 Response 实体。
Response getResponseWithInterceptorChain() throws IOException {
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);
}
创建了一系列拦截器，链式处理，缓存、连接都通过拦截器链的节点实现。、
三、拦截器
拦截器顺序
客户端自定义拦截器
retryAndFollowUpInterceptor 拦截器
BridgeInterceptor 桥接
CacheInterceptor 缓存
ConnectInterceptor 连接
networkInterceptors 网络
CallServerInterceptor 数据流读写
RealInterceptorChain 类是在拦截器之间传递的节点，第一次创建时，index 初始是0，入参传递 originalRequest 原始请求与拦截器列表。
在 RealInterceptorChain 类的 proceed() 方法，开始链式处理，利用拦截器表中各层拦截处理 Request 请求和 Response 回复。
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
RealConnection connection) throws IOException {
if (index >= interceptors.size()) throw new AssertionError();
calls++;
..
RealInterceptorChain next = new RealInterceptorChain(
interceptors, streamAllocation, httpCodec, connection, index + 1, request);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
//抛出异常
}
if (response == null) {
//抛出异常
}
return response;
}
查找拦截器链表 index 索引的 Interceptor，新建 index++ 的 RealInterceptorChain 节点，触发 Interceptor的intercept() 方法，传递新 Chain。
列表中每一个 Interceptor 拦截器的 intercept() 方法。
- 处理 Request 请求
- Chain 节点的 proceed() 方法
- 处理 Response 答复
每一个 Chain 节点 proceed() 方法逻辑。
- 查找下一个拦截器
- 创建新 Chain 节点
- 拦截器 intercept() 方法，传入新节点
当 index++索引到达最后一个拦截器 CallServerInterceptor 时，真正向 Server 发送数据，获取 Response，然后递归一层层按原路返回。
拦截器列表前部分 Interceptor 优先处理原始 Request，后部分优先处理原始 Response。
public interface Interceptor {
Response intercept(Chain chain) throws IOException;
interface Chain {
Request request();
Response proceed(Request request) throws IOException;
Connection connection();
}
}
拦截器设计是一个递归调用过程，Chain 对象是链节点，proceed() 方法处理时，创建 index++的 Chain 新节点，传递给下一个拦截器。
proceed() 方法流入 Request 请求，流出 Response 答复，拦截器目的是层层截断流入与流出，先截流，加工处理，再放流。
四、缓存设计
五、连接池
六、数据流
任重而道远
