源码解析一次OKHttp请求的过程

OkHttp这个库有多优秀作为Androider大家心里都明白，应该说合格的开发者都认识它。那么，这里简单看个OKHttp的接口请求姿势：

OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
        .url("https://www.xxxx.com/xxx/xxx/xxx")
        .build();
Call call = okHttpClient.newCall(request);
//开始执行异步接口请求
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
    	// 这里接口请求失败
    }
    @Override
    public void onResponse(Call call, Response response) throws IOException {
    	// 这里接口请求成功
    }
});

所以很明显了弄懂了上面几个类的是干嘛、上个几个流程做了什么自然就明白了OKHttp的执行流程了，那么就开始分析吧。

OKHttp请求中需要的对象

Request这个类是典型的’Builder’设计模式，看一眼他的成员属性就知道这个类是干嘛的了。

public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final @Nullable RequestBody body;
  final Object tag;
  .
  .
  .
  }

看看变量名就知道了这个类封装那些玩意，还是很愉快的完成了一小步。

OkHttpClient这个类类似个Manager类，里面的成员属性自然也比较多了。
我们重点关注Dispatcher这个线程池属性：

  // 可以传入线程池，从而自定义OKHttp线程池 
  public Dispatcher(ExecutorService executorService) {
    this.executorService = executorService;
  }

  public Dispatcher() {
  }
  // 初始化线程池 
  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;
  }

所以Dispatcher就是一个线程池管理类，用于分发每一次的Http请求。

Call是接口真正的实现类是RealCall，而RealCall有个内部类叫AsyncCall是个接口，最终加入Dispatcher线程池的就是AsyncCall对象。

执行Http请求操作

我们从okHttpClient.newCall操作开始阅读：

  /**
   * Prepares the {@code request} to be executed at some point in the future.
   */
  @Override public Call newCall(Request request) {
    return new RealCall(this, request, false /* for web socket */);
  }

所以这里封装了一个RealCall对象然后执行enqueue方法，我们进入该方法看看一下代码：

  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

再看最后一行代码会执行Dispatcher.enqueue方法，同样的进入看看代码怎么执行的：

  synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

由于AsyncCall是实现了NamedRunnable接口，所以线程池就会执行NamedRunnable.run方法，这样子自然就执行到AsyncCall.execute方法。

    @Override 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 {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

我们可以看到这里直接通过getResponseWithInterceptorChain()方法直接得到Response然后通过Callback回调数据回去。

拦截器Interceptor

通过上面我们知道已经得到Response基本上可以说已经结束了一个流程，这里并不细节的解释每个拦截器的代码，只是介绍一下拦截器的调用时序，所以仍然先看一下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);
    return chain.proceed(originalRequest);
  }

我们可以看到系统已经为我们定义几个默认的拦截器，他们的作用一起调用时序如下：
在这里插入图片描述
这里知道了调用时序，那从什么时候触发调用？

Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);

我们可以看到是先封装一个RealInterceptorChain对象，然后执行proceed方法自然就会执行每一个interceptor.intercept方法。OKHttp的所有精髓之一就是拦截器的使用…

最后，这里我们也可以明白一点addInterceptor / addNetworkInterceptor两者之间有何不同了，因为他们俩的调用时序不一样。

更多拦截器的分析，将在未来找时间分析。