okhttp溯源之工作流程

    okhttp是square公司推出的网络请求框架，已经逐渐成为android开发者的首选网络框架，我们从使用入手来分析一下okhttp的工作流程。

    okhttp的使用：

// 1.创建client对象
OkHttpClient client=new OkHttpClient();
// 2.创建请求request
Request request=new Request.Builder()
                .url(url)
                .build();
// 3.执行请求拿到响应结果
try(Response response=client.newCall(request).execute()){
    return response.body().string();
}

    OkHttpClient是okhttp的请求构建类，第一步OkHttpClient的构造方法中初始化了一些对象。第二步是根据url创建了http请求信息的包装类Request，request中包含了http请求的一系列请求信息，包括url、header、method等。第三步是执行请求拿到响应结果Response，Response是http请求结果的包装类，里面包含了请求结果的详细信息。

   client和request是基本对象的创建，没有特别值得说的地方，我们着重分析第三步执行请求拿到响应结果。

   client.newCall方法拿到了realCall对象，而execute正是realCall的重要方法，RealCall是准备执行的请求、执行请求取消请求的操作都在此类中

final class RealCall implements Call {
    ...
    public Response execute() throws IOException {
    synchronized (this) {
      //如果已经执行过了，抛出异常
      if (executed) throw new IllegalStateException("Already Executed");
      //将执行状态修改为执行过
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    try {
      //通过dipatcher来统一进行调度执行
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);
    }
  }

}

      上面代码中可以看到，realCall将执行的操作交给Dispatcher来进行统一调度执行，dispatcher调用了RealCall的内部类AsyncCall的excute方法进行执行

final class AsyncCall extends NamedRunnable {
    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 {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
}

      上述代码的核心操作是调用了getResponseWithInterceptorChain方法拿到响应结果

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 (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    //发送请求 读取响应数据  拦截器
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

    此处使用了责任链模式，依次经过拦截器RetryAndFollowupInterceptor、BridgeInterceptor、CacheInterceptor、ConnectInterceptor和CallServerInterceptor，经过失败重试、请求转换、缓存处理、服务器连接和服务器数据请求拿到服务器响应结果Response，拦截器在RealInterceptor中统一存储并控制。