OkHttp

写在开头

文章地址：https://juejin.im/post/5e1be39b6fb9a02fcd130d1f

本文是对该文章的个人理解总结，仅用于个人复习，有需要看此文章即可。

大纲

• 使用
• 解析
• 责任链模式
• 总结

使用

最简单的“Get”请求

// 实例客户端
val okHttpClient = OkHttpClient()
// 构建 request 请求参数
val request = Request.Builder().url("http://www.baidu.com").build()
//执行同步请求并返回
val response = okHttpClient.newCall(request).execute()

解析

解析上述三步

1. OkHttpClient（）

  1.第一步
  public OkHttpClient() {
    //实例 Builder，构建者模式
    this(new Builder());
  }
  
  2.第二步
  OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    //...其他配置
  }
  
  public static final class Builder {
  Dispatcher dispatcher;
  //...其他配置

  3.第三步
  //new Builder() 会创建一系列默认配置
  public Builder() {
  dispatcher = new Dispatcher();
  //...其他配置
  }
}

总结来说：实例 OkHttp()，就会实例一个 Builder()，它里面会初始化一系列配置。（拦截器，请求超时等）

2. Request.Builder().url("地址").build()

显然也是使用了“Builder”模式

public Builder() {
  this.method = "GET";
  this.headers = new Headers.Builder();
}

默认“GET”方法，这里我们再加了请求的“url”

3. okHttpClient.newCall(request)

  @Override public Call newCall(Request request) {
    return new RealCall(this, request, false /* for web socket */);
  }
  
  RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    //初始化一些配置
    ...
  }

可以看出“okHttpClient”的“newCall”实际是使用了“RealCall”类

4. execute()

最后调用“RealCall”的“execute”请求

@Override public Response execute() throws IOException {
  //同步检查有没有多次执行过
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  //捕获栈堆跟踪，不需要理会
  captureCallStackTrace();
  try {
    //1. 添加请求到队列
    client.dispatcher().executed(this);
    //2. 重点，可先看最后的责任链的个人理解
    Response result = getResponseWithInterceptorChain();
    if (result == null) throw new IOException("Canceled");
    return result;
  } finally {
    //3. 从队列移除请求
    client.dispatcher().finished(this);
  }
}

//1. 添加请求到队列，从 okHttpClient 拿到 dispatcher（ Dispatcher 类）
//   dispatcher 在实例 Buidler 时初始化了
//   runningSyncCall 是 一个双端队列 Deque
synchronized void executed(RealCall call) {
  runningSyncCalls.add(call);
}

//3. 从队列移除请求，没有这个 call 就报错
private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
  int runningCallsCount;
  Runnable idleCallback;
  synchronized (this) {
    if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
    ...
  }
  ...
}

//2. 重点，使用“责任链模式”获取请求结果
Response getResponseWithInterceptorChain() throws IOException {
  //实例 list 存放一些列拦截器
  List<Interceptor> interceptors = new ArrayList<>();
  //将自己在 OkHttpClient 添加的拦截器放入，这里是我没有添加
  interceptors.addAll(client.interceptors());
  //重试并跟踪拦截器，负责失败的重试及重定向
  interceptors.add(retryAndFollowUpInterceptor);
  //负责添加必要的“Header”，接收响应式，移除必要的“Header”
  interceptors.add(new BridgeInterceptor(client.cookieJar()));
  //负责缓存的读取，更新
  interceptors.add(new CacheInterceptor(client.internalCache()));
  //负责和服务器的连接
  interceptors.add(new ConnectInterceptor(client));
  //若不是 webSocket 请求，默认是false
  if (!forWebSocket) {
    // okHttpClient 设置的网络拦截器 ，这里也没有设置
    interceptors.addAll(client.networkInterceptors());
  }
  //负责向服务器发送请求数据，从服务器相应数据
  interceptors.add(new CallServerInterceptor(forWebSocket));
  //责任链实例，RealInterceptorChain 实例
  Interceptor.Chain chain = new RealInterceptorChain(
      interceptors, null, null, null, 0, originalRequest);
  //开始责任链模式调用
  return chain.proceed(originalRequest);
}

5. chain.proceed(originalRequest)

// RealInterceptorChain 的 proceed 方法
@Override public Response proceed(Request request) throws IOException {
  //这里的 streamAllocation, httpCodec, connection 开始是空的
  //但经过责任链的调用，将拦截器的结果返回来后就不为空
  return proceed(request, streamAllocation, httpCodec, connection);
}

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
    RealConnection connection) throws IOException {
  //若 index 大于等于拦截器集合 就报错
  //开始为零，其余的都是其他拦截器责任链模式传来的索引
  //看下面的 RealInterceptorChain next = new RealInterceptorChain
  if (index >= interceptors.size()) throw new AssertionError();
  //标记，一般都是 ++ 后为1， 除非同一个Chain实例被调用了多次 proceed
  calls++;

  //一开始 httpCode，connection为 null
  if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
    throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
        + " must retain the same host and port");
  }
  // httpCodec同上，calls：大于 1 表示自己多次调用了 proceed
  if (this.httpCodec != null && calls > 1) {
    throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
        + " must call proceed() exactly once");
  }
  // 实例下一个拦截器 （参数：index + 1）
  RealInterceptorChain next = new RealInterceptorChain(
      interceptors, streamAllocation, httpCodec, connection, index + 1, request);
  Interceptor interceptor = interceptors.get(index);
  //调用当前拦截器的 interceptor方法，传入下一个拦截器责任链实例
  //该拦截器处理到处理不了的时候，就通过这个责任链的next.processd 回到该方法
  //简单来说：有必要就通过这个实例叫下一个拦截器做事
  Response response = interceptor.intercept(next);

  if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
    throw new IllegalStateException("network interceptor " + interceptor
        + " must call proceed() exactly once");
  }

  if (response == null) {
    throw new NullPointerException("interceptor " + interceptor + " returned null");
  }
  return response;
}

每一个拦截器的 intercept 方法里都有一个 chain.proceed，除了集合添加的最后一个 CallServerInterceptor，因为它之后没有拦截器了。

在 CallServerInterceptor 返回 response 后，其他拦截器再处理完 自己chain.proceed后的方法，最终会返回一个完整的 response

举例看第一个拦截器 “RetryAndFollowUpInterceptor”，这个拦截器就组装了 StreamAllocation streamAllocation参数

  //Chain：这里是下一个拦截器的责任链
  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    //实例 StreamAllocation
    streamAllocation = new StreamAllocation(
        client.connectionPool(), createAddress(request.url()), callStackTrace);

      ...
      Response response = null;
      boolean releaseConnection = true;
      try {
        //将 streamAllocation 也返回给下一个拦截器处理
        response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);
        releaseConnection = false;
      } catch (RouteException e) {
      ...
      } 
      ...
  }

责任链模式

我能做的我做，不能的交给下一个人做

比如（这例子是模仿其他作者的举例写的，但实在忘记在哪看的 - -）：

主题：公司活动，需要申请 500元 经费。

公司审批经费的额度根据职位不同而不同，部门经理只能批200元，总经理能批1000元。这时我交给了部门经理审批，部门经理看数目后提交给总经理，总经理确定签字。

这就是责任链，能做的就做，不行的就给下一个人处理，自己不再负责，当事人不清楚是谁最终完成了签字。

交给别人后自己不再负责，这也是纯种的责任链模式，但纯种的责任链模式在实际需求中比较少。

实际需求中的责任链，一般都是：我先处理一些东西，发现有些东西处理不了，然后交给其他人继续处理，最后将某些结果返回来再接着处理，OkHttp的责任链模式就是如此。

总结

上面讲了同步请求，异步请求最终也会调用 getResponseWithInterceptorChain() 组装数据，总体流程图如下，

流程图

注：原文里面还有一些拦截器的详解