Android OkHttp（三）源码解析

    前面两篇文章，我们介绍了OKHttp的基本用法，今天这篇文章将从OkHttp源码的角度来分析OkHttp的整个工作流程。

初始化一个OkHttpClient对象，

    OkHttpClient mOkHttpClient = new OkHttpClient();

OkHttpClient的构造函数中又初始化了一个Builder对象，

   public OkHttpClient() {
    this(new Builder());
  }

Builder的构造函数中，默认会创建对象以及一些属性，Builder对象是用来构造网络请求的。这种设计模式和Android的对话框中的Builder几乎是一个意思。

 public Builder() {
      dispatcher = new Dispatcher();
      protocols = DEFAULT_PROTOCOLS;
      connectionSpecs = DEFAULT_CONNECTION_SPECS;
      proxySelector = ProxySelector.getDefault();
      cookieJar = CookieJar.NO_COOKIES;
      socketFactory = SocketFactory.getDefault();
      hostnameVerifier = OkHostnameVerifier.INSTANCE;
      certificatePinner = CertificatePinner.DEFAULT;
      proxyAuthenticator = Authenticator.NONE;
      authenticator = Authenticator.NONE;
      connectionPool = new ConnectionPool();
      dns = Dns.SYSTEM;
      followSslRedirects = true;
      followRedirects = true;
      retryOnConnectionFailure = true;
      connectTimeout = 10_000;
      readTimeout = 10_000;
      writeTimeout = 10_000;
    }

接着，创建一个请求，

  Request request = new Request.Builder()  
      .url(url)  
      .build(); 

Request类是HTTP请求，它携带了请求地址、请求方法、请求头部、请求体以及其他信息。它也是通过Builder模式创建的。Request.Builder().build()源码，

    public Request build() {
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
    }

Request的构造方法，

   private Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tag = builder.tag != null ? builder.tag : this;
  }

发起请求有两种方式，一种是同步，一种是异步，下面分别看看如何实现，

同步请求，

 Response  response = mOkHttpClient.newCall(request).execute();

Response是HTTP响应，它继承自Closeable（Closeable继承自AutoCloseable，AutoCloseable资源自动关闭的接口），它携带了请求、网络请求协议、返回状态码、请求头、响应体等等，其中，网络请求协议是Protocol，Protocol是一个枚举类型，包含4中类型，

 public enum Protocol {
  /**
   * An obsolete plaintext framing that does not use persistent sockets by default.
   */
  HTTP_1_0("http/1.0"),

  /**
   * A plaintext framing that includes persistent connections.
   *
   * <p>This version of OkHttp implements <a href="http://www.ietf.org/rfc/rfc2616.txt">RFC
   * 2616</a>, and tracks revisions to that spec.
   */
  HTTP_1_1("http/1.1"),

  /**
   * Chromium's binary-framed protocol that includes header compression, multiplexing multiple
   * requests on the same socket, and server-push. HTTP/1.1 semantics are layered on SPDY/3.
   *
   * <p>This version of OkHttp implements SPDY 3 <a
   * href="http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1">draft 3.1</a>. Future
   * releases of OkHttp may use this identifier for a newer draft of the SPDY spec.
   */
  SPDY_3("spdy/3.1"),

  /**
   * The IETF's binary-framed protocol that includes header compression, multiplexing multiple
   * requests on the same socket, and server-push. HTTP/1.1 semantics are layered on HTTP/2.
   *
   * <p>HTTP/2 requires deployments of HTTP/2 that use TLS 1.2 support {@linkplain
   * CipherSuite#TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256} , present in Java 8+ and Android 5+. Servers
   * that enforce this may send an exception message including the string {@code
   * INADEQUATE_SECURITY}.
   */
  HTTP_2("h2");
  
  }

接着看

OkHttpClient.newCall(request);

Call类是一个准备执行的请求，它可以被取消，它代表着一个单一的请求/响应流，不能被执行两次。Call类是一个接口，

public interface Call {
  /** Returns the original request that initiated this call. */
  Request request();

  /**
   * Invokes the request immediately, and blocks until the response can be processed or is in
   * error.
   *
   * <p>The caller may read the response body with the response's {@link Response#body} method. To
   * avoid leaking resources callers must {@linkplain ResponseBody close the response body}.
   *
   * <p>Note that transport-layer success (receiving a HTTP response code, headers and body) does
   * not necessarily indicate application-layer success: {@code response} may still indicate an
   * unhappy HTTP response code like 404 or 500.
   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity
   * problem or timeout. Because networks can fail during an exchange, it is possible that the
   * remote server accepted the request before the failure.
   * @throws IllegalStateException when the call has already been executed.
   */
  Response execute() throws IOException;

  /**
   * Schedules the request to be executed at some point in the future.
   *
   * <p>The {@link OkHttpClient#dispatcher dispatcher} defines when the request will run: usually
   * immediately unless there are several other requests currently being executed.
   *
   * <p>This client will later call back {@code responseCallback} with either an HTTP response or a
   * failure exception.
   *
   * @throws IllegalStateException when the call has already been executed.
   */
  void enqueue(Callback responseCallback);

  /** Cancels the request, if possible. Requests that are already complete cannot be canceled. */
  void cancel();

  /**
   * Returns true if this call has been either {@linkplain #execute() executed} or {@linkplain
   * #enqueue(Callback) enqueued}. It is an error to execute a call more than once.
   */
  boolean isExecuted();

  boolean isCanceled();

  interface Factory {
    Call newCall(Request request);
  }
}

newCall()方法是创建一个Call对象，

    @Override 
    public Call newCall(Request request) {
    return new RealCall(this, request);
  }

RealCall类实现了Call类，下面展示RealCall()方法的代码，

    protected RealCall(OkHttpClient client, Request originalRequest) {
    this.client = client;
    this.originalRequest = originalRequest;
    this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client);
  }

接着是RealCall的execute()方法。execute()方法是同步方法，即一直等待http请求, 直到返回了响应. 在这之间会阻塞进程, 所以通过同步方法不能在Android的主线程中执行, 否则会报错。

OKHttp提供了execute()方法（同步方法）和enqueue()方法（异步方法），下面我们先看看execute()方法（同步方法），

   @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } finally {
      client.dispatcher().finished(this);
    }
  }

execute()方法，首先判断是否已执行过，如果已经执行过，则抛出异常信息，也就是说一次Call实例只能调用一次execute()方法，和我们之前说的一样。

如果未执行，则调用Dispatcher类的executed()方法将该Call加入到一个双端队列中，

   ...
   private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();//双端队列
   ...
       /** Used by {@code Call#execute} to signal it is in-flight. */
  synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

 接着调用getResponseWithInterceptorChain()方法返回Response对象，最后finally中，调用Dispatcher的finished()方法，在从已经执行的双端队列中移除本次Call。

 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!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

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

通过上面分析，真正发出网络请求，返回结果应该是getResponseWithInterceptorChain()方法，那么接下来，主要看看这个方法

  private 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 (!retryAndFollowUpInterceptor.isForWebSocket()) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(
        retryAndFollowUpInterceptor.isForWebSocket()));

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

仔细查看便会发现，该方法是组装各种拦截器为一个拦截器链，最后调用RealInterceptorChain的proceed()方法，来处理这个请求，

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

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpStream httpStream,
      Connection 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.httpStream != null && !sameConnection(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.httpStream != 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, httpStream, 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 (httpStream != 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;
  }

拦截器Interceptor和拦截器链Chain都是接口，

public interface Interceptor {
  Response intercept(Chain chain) throws IOException;

  interface Chain {
    Request request();

    Response proceed(Request request) throws IOException;

    Connection connection();
  }
}

下面用一张流程图来说明拦截器链递归从拦截器中返回Response（这个过程很类似Android中的事件处理机制）

下面再看看enqueue()方法（异步方法），指在另外的工作线程中执行http请求, 请求时不会阻塞当前的线程, 所以可以在Android主线程中使用。

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

该方法和同步方法一样，首先都校验这个Call是否已经被执行，如果执行过，就报异常。如果为执行，则调用Dispatcher分发器的enqueue()方法。首先，我们看看AsyncCall这个类，

 final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    private AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl().toString());
      this.responseCallback = responseCallback;
    }

    String host() {
      return originalRequest.url().host();
    }

    Request request() {
      return originalRequest;
    }

    RealCall get() {
      return RealCall.this;
    }

    @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);
      }
    }
  }

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

  public NamedRunnable(String format, Object... args) {
    this.name = Util.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，在run()方法中调用了execute()方法，在该方法中，我们又看到既熟悉又陌生的代码（getResponseWithInterceptorChain()），

 Response response = getResponseWithInterceptorChain();

执行该方法后，根据响应结果设置回调方法的结果。AsyncCall执行完调用Dispatcher的finished(this)方法，

 void finished(AsyncCall call) {
    finished(runningAsyncCalls, call, true);
  }

 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!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

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

finished()方法先从runningAsyncCalls(异步请求队列)删除已经执行的异步请求，然后接着调用了promoteCalls()方法，

 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();

      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
      }

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

首先判断runningAsyncCalls(异步请求队列)是否还有请求，如果有，则返回；否则readyAsyncCalls（异步调用准备任务）是否为空，如果为空，则返回；否则，循环readyAsyncCalls（异步调用准备任务），将call加入到runningAsyncCalls(异步请求队列)中，并在readyAsyncCalls（异步调用准备任务）删除掉该call，接着线程池执行call。

下面接着看Dispatcher分发器的enqueue()方法，

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

如果runningAsyncCalls的大小小于最大请求数量（最大线程数量、并发数量）并且call小于最大主机请求限制，那么将call 加入到runningAsyncCalls中，接着线程池执行call；否则，将call加入到readyAsyncCalls（异步调用准备任务）。

PS: runningCallsForHost()方法，循环判断cal的hostl和runningAsyncCalls的中的call的host相同的数量。同一请求是否超过想过请求同时存在的最大值。

  private int runningCallsForHost(AsyncCall call) {
    int result = 0;
    for (AsyncCall c : runningAsyncCalls) {
      if (c.host().equals(call.host())) result++;
    }
    return result;
  }

可以看到请求的最核心代码，与Dispatcher类分不开，下面就看看Dispatcher类，Dispatcher是异步请求的策略，

public final class Dispatcher {
  private int maxRequests = 64;
  private int maxRequestsPerHost = 5;
  private Runnable idleCallback;

  /** 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维护了如下变量，
    int maxRequests = 64: 最大并发请求数为64
    int maxRequestsPerHost = 5: 每个主机最大请求数为5
    Runnable idleCallback：Runnable对象，在删除任务时执行
    ExecutorService executorService：消费者池（也就是线程池）
    Deque<AsyncCall> readyAsyncCalls：缓存，异步调用准备执行任务
    Deque<AsyncCall> runningAsyncCalls：正在运行的异步任务，包含取消尚未完成的调用

    Deque<RealCall> runningSyncCalls： 正在运行的同步任务，包含取消尚未完成的调用

至此，OKHttp的源码分析就结束了！希望本篇文章对读者有所收获！

下面结合本篇文章，总结OKHttp的整体流程，流程图如下所示，