前言

此篇文章将会解析OkHttp的源码，因为OkHttp的的源码有很多部分，我们这篇来讲解OkHttp的网络请求，我们还是从OkHttp的异步操作开始解析，OkHttp版本为3.7。

OkHttp的请求网络流程

当我们要请求网络的时候需要调用OkHttpClient的newCall(request)，然后在进行execute()或者enqueue()操作，当调用newCall()方法时候，会调用如下代码。

@Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
}

它其实返回的是一个RealCall类，我们调用enqueue()异步请求方法实际上是调用了RealCall的enqueue()方法。

//RealCall的enqueue()方法源码
//从这里开始调用
@Override public void enqueue(Callback responseCallback) {
    enqueue(responseCallback, false);
}

@Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    //这里交给dispatcher进行调度
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

从这里源码可以看到，最终的请求是dispatcher的enqueue()来完成的，我们接下来就来分析这个。

public final class Dispatcher {

    //最大并发请求数
    private int maxRequests = 64;
    //每个主机的最大请求数
    private int maxRequestsPerHost = 5;
    
    /** Executes calls. Created lazily. */
    //消费者线程池
    private ExecutorService executorService;

    /** Ready async calls in the order they'll be run. */
    //将要运行的异步消息队列
    private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

    /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
    //正在运行的异步请求队列
    private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

    /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
    //正在运行的同步请求队列
    private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

    ......
}

上面为Dispatcher类的部分代码，主要用于控制并发的请求，接下来我们看看Dispatcher的构造方法。

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有两个构造方法，可以使用自己设定的线程池，也如果没有线程池，则会在正式请求网络前调用executorService()来创建默认线程池，这个线程池类似于CachedThreadPool，比较适合执行大量的耗时比较少的额任务。然后我们回到前面之前讲过的就是当RealCall调用enqueue()方法时候，实际上就是调用了Dispatcher的enqueue()方法，它的代码如下。

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      //这里通过executorService()创建线程池然后通过线程池的execute()会开始执行AsyncCall的execute()
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
}

当正在运行的异步请求队列的数量小于64并且正在运行的请求主机数小于5时，把请求加载到到runningAsyncCalls中并在线程池中执行，否则就加在到readyAsyncCalls中进行缓存等待，线程池中传进来的参数是AsyncCall，它是RealCall的内部类，其内部也实现了execute()方法，代码如下。

//AsyncCall的execute()方法源码
@Override protected void execute() {
  boolean signalledCallback = false;
  try {
    ......
  } catch (IOException e) {
    ......
  } finally {
    client.dispatcher().finished(this);
  }
}

无论这个请求的结果如何，都会执行finaly块里面的代码，我们来看看里面是什么。

void finished(RealCall call) {
    finished(runningSyncCalls, call, false);
}

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!");
    //这里开始检查是否为异步请求，检查等候的队列，readyAsyncCalls
    if (promoteCalls) promoteCalls();
    runningCallsCount = runningCallsCount();
    idleCallback = this.idleCallback;
    }

    if (runningCallsCount == 0 && idleCallback != null) {
        idleCallback.run();
    }
}

private void promoteCalls() {
    //检查 运行队列 和 等待队列
    if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
    if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.
    
    //将等待队列加入到运行队列中
    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        AsyncCall call = i.next();
        //相同host的请求没有达到最大，加入到运行队列
        if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
    }

    if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
    }
}

这里是通过调度器移除队列，并且判断是否存在等待队列，如果存在，检查执行队列是否达到最大值，如果没有将等待队列变为执行队列。这样也就确保了等待队列被执行。

好了接下来我们回到AsyncCall这个类上面来，我们会发现它继承了NamedRunnable。

public abstract class NamedRunnable implements Runnable {
  protected final String name;

  public NamedRunnable(String format, Object... args) {
    this.name = String.format(format, args);
  }

  @Override public final void run() {
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      execute();
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

  protected abstract void execute();
}

然后发现了，其实本质上AsyncCall就是一个Runnable，线程池会执行AsyncCall的execute()方法。接下来我们来看看AsyncCall的execute()源码。

//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，很明显这是在请求网络，我们就着重看这个。我们先看getResponseWithInterceptorChain()的源码。

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    //责任链
    List<Interceptor> interceptors = new ArrayList<>();
    配置OkhttpClient时设置的拦截器，可以由用户自己设置。
    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) {
        //配置OkHttpClient时设置的networkInterceptors
        interceptors.addAll(client.networkInterceptors());
    }
    //执行流操作
    interceptors.add(new CallServerInterceptor(forWebSocket));
    //创建责任链
    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    //执行责任链
    return chain.proceed(originalRequest);
}

我们发现，这里其实是运用了责任链模式，这里也是OkHttp最精髓的地方。从上述代码中，可以看出都实现了Interceptor接口，这是okhttp最核心的部分，采用责任链的模式来使每个功能分开，每个Interceptor（拦截器）自行完成自己的任务，并且将不属于自己的任务交给下一个，简化了各自的责任和逻辑。我们暂时先不看拦截器的实现，这里接着往下看，这里是通过RealInterceptorChain创建了责任链，也就是接来执行RealInterceptorChain的proceed()方法。

@Override public Response proceed(Request request) throws IOException {
    return proceed(request, streamAllocation, httpCodec, connection);
}

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
    RealConnection connection) throws IOException {
        
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

    // If we already have a stream, confirm that the incoming request will use it.
    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");
    }

    // If we already have a stream, confirm that this is the only call to chain.proceed().
    if (this.httpCodec != null && calls > 1) {
        throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
            + " must call proceed() exactly once");
    }

    // Call the next interceptor in the chain.
    //这里是具体实现
    RealInterceptorChain next = new RealInterceptorChain(
        interceptors, streamAllocation, httpCodec, connection, index + 1, request);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
        throw new IllegalStateException("network interceptor " + interceptor
            + " must call proceed() exactly once");
    }

    // Confirm that the intercepted response isn't null.
    if (response == null) {
        throw new NullPointerException("interceptor " + interceptor + " returned null");
    }

    return response;
}

从这段实现可以看出，是按照添加到 interceptors 集合的顺序，逐个往下调用拦截器的intercept()方法，然后最终返回处理后的response。到这里其实整个网络请求的整个流程就到此结束了，其实重点就是里面的拦截器的具体实现。关于拦截器后面我会单独来写一篇来讲述里面每个拦截器的实现。这里最后放一张网络请求的流程图。

OkHttp的请求过程

参考

• [刘望舒]Android进阶之光