Okhttp 思考

---

Okhttp 基础知识导图

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  void finished(Deque 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 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(), 
                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 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 答复，拦截器目的是层层截断流入与流出，先截流，加工处理，再放流。

四、缓存设计

Okhttp 缓存设计

五、连接池

Okhttp 连接池

六、数据流

Okhttp 数据流

---

任重而道远