• Okhttp在代码中的构建方式

OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS)
                .readTimeout(DEFAULT_READ_TIME_OUT,TimeUnit.SECONDS)
                .writeTimeout(DEFAULT_READ_TIME_OUT,TimeUnit.SECONDS)
                .retryOnConnectionFailure(true)
                .addNetworkInterceptor(getCacheInterceptor()).cache(cache)//设置缓存
                .addInterceptor(getHttpLoggingInterceptor())//打印日志
                .build();

Request request = new Request.Builder().url("xxxx").build;
Call call = client.newCall(request);
//同步请求
Response response = call.execute();
//异步请求
call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {  
           
            }
        });

同步和异步请求在使用OkHttp时，构建client、request、call的过程是一样的，只在最后执行请求时存在区别，内部的实现也存在区别。

• 根据构建方式，我们先来看一下Okhttp的源码
  （1）先看一下OkHttpClient的内部类Builder部分代码，主要是成员变量

public static final class Builder {
    Dispatcher dispatcher;//重中之重，分发器，异步请求的分发，就绪队列还是执行队列
    @Nullable Proxy proxy;
    List<Protocol> protocols;
    List<ConnectionSpec> connectionSpecs;
    final List<Interceptor> interceptors = new ArrayList<>();
    final List<Interceptor> networkInterceptors = new ArrayList<>();
    EventListener.Factory eventListenerFactory;
    ProxySelector proxySelector;
    CookieJar cookieJar;
    @Nullable Cache cache;
    @Nullable InternalCache internalCache;
    SocketFactory socketFactory;
    @Nullable SSLSocketFactory sslSocketFactory;
    @Nullable CertificateChainCleaner certificateChainCleaner;
    HostnameVerifier hostnameVerifier;
    CertificatePinner certificatePinner;
    Authenticator proxyAuthenticator;
    Authenticator authenticator;
    ConnectionPool connectionPool;//连接池，非常重要
    Dns dns;
    boolean followSslRedirects;
    boolean followRedirects;
    boolean retryOnConnectionFailure;
    int connectTimeout;
    int readTimeout;
    int writeTimeout;
    int pingInterval;

    public Builder() {
      dispatcher = new Dispatcher();
      protocols = DEFAULT_PROTOCOLS;
      connectionSpecs = DEFAULT_CONNECTION_SPECS;
      eventListenerFactory = EventListener.factory(EventListener.NONE);
      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;
      pingInterval = 0;
    }

    Builder(OkHttpClient okHttpClient) {
      this.dispatcher = okHttpClient.dispatcher;
      this.proxy = okHttpClient.proxy;
      this.protocols = okHttpClient.protocols;
      this.connectionSpecs = okHttpClient.connectionSpecs;
      this.interceptors.addAll(okHttpClient.interceptors);
      this.networkInterceptors.addAll(okHttpClient.networkInterceptors);
      this.eventListenerFactory = okHttpClient.eventListenerFactory;
      this.proxySelector = okHttpClient.proxySelector;
      this.cookieJar = okHttpClient.cookieJar;
      this.internalCache = okHttpClient.internalCache;
      this.cache = okHttpClient.cache;
      this.socketFactory = okHttpClient.socketFactory;
      this.sslSocketFactory = okHttpClient.sslSocketFactory;
      this.certificateChainCleaner = okHttpClient.certificateChainCleaner;
      this.hostnameVerifier = okHttpClient.hostnameVerifier;
      this.certificatePinner = okHttpClient.certificatePinner;
      this.proxyAuthenticator = okHttpClient.proxyAuthenticator;
      this.authenticator = okHttpClient.authenticator;
      this.connectionPool = okHttpClient.connectionPool;
      this.dns = okHttpClient.dns;
      this.followSslRedirects = okHttpClient.followSslRedirects;
      this.followRedirects = okHttpClient.followRedirects;
      this.retryOnConnectionFailure = okHttpClient.retryOnConnectionFailure;
      this.connectTimeout = okHttpClient.connectTimeout;
      this.readTimeout = okHttpClient.readTimeout;
      this.writeTimeout = okHttpClient.writeTimeout;
      this.pingInterval = okHttpClient.pingInterval;
    }
}

Dispatcher dispatcher;//重中之重，分发器，异步请求的分发，就绪队列还是执行队列。同步请求，简单放入同步请求队列执行。
ConnectionPool connectionPool;//连接池，非常重要，客户端和服务器端每一个连接是一个connection，而每一个connection放入连接池中进行统一管理。（1）当请求的url是同一个时，可以复用。（2）ConnectionPool还可以管理连接的策略（打开关闭，复用等）

（2）Request同样也是Builder构建模式创建的，其中包含了请求的url，请求头，网络请求方法，请求体等等内容。
（3）Call call = client.newCall(request)生成Call请求对象。

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

内部实际是接口Call的实现类ReallCall执行的newRealCall方法。那么我们来看ReallCall.newReallCall做了什么。

static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    // Safely publish the Call instance to the EventListener.
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }

我们首先看下在创建RealCall的构造方法中做了哪些工作。

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

可以看到RealCall持有了前两步创建的OkHttpClient对象和Request对象，除此之外还创建了一个重定向拦截器RetryAndFollowUpInterceptor，后续我们会介绍。

上面三个步骤，无论是同步还是异步都是一样的，那么他们之间的区别就是在下面第四步

（4）同步请求

Response response = call.execute();

我们来看源码call.execute()具体怎么执行

@Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();//捕捉异常堆栈信息，和主流程无关，看源码这种过滤掉即可。
    eventListener.callStart(this);
    try {
      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);
    }
  }

首先在同步代码块中，判断executed，如果为true则抛出异常，否则设置为true，这说明同一个http请求只能请求一次。

client.dispatcher().executed(this);我们主要来看这一句代码，dispatcher()方法返回了一个Dispatcher对象，具体来看Dispatcher的executed方法。

synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

可以看到，直接将call添加到同步请求执行队列当中。

返回execute主流程中继续看源码：
Response result = getResponseWithInterceptorChain();

通过处理拦截器链后获取到服务器的响应结果，具体后续详细介绍。

最后一步注意finally中的代码client.dispatcher().finished(this);

最终还是通过client的分发器结束移出请求call对象，追踪代码

/** Used by {@code Call#execute} to signal completion. */
  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();
    }
  }

我们可以看到将当前Call对象从同步请求执行队列中移除，并且通过runningCallsCount()方法重新计算了当前正在运行的异步和同步请求的和。同时我们可以注意到一个bool参数promoteCalls在同步请求中是false，导致promoteCalls()方法不会执行，但是在异步请求中是会执行的，这也就是同步和异步之间的一个区别。

总结一下分发器在同步请求中的作用：将同步请求添加和移除同步请求
队列

异步请求前三步和上边是一样的，只有最后一步发起请求不同，追踪源码：

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

异步请求方法enqueue中前几步依然和同步方法的execute方法相同，不同的在最后一步client.dispatcher().enqueue(new AsyncCall(responseCallback));

那么我们来跟进代码看一下：

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

final class AsyncCall extends NamedRunnable

在Dispatcher类中定义了两个值，一个maxRequests为64 ，一个maxRequestsPerHost为5，当前运行的异步请求不超过64个且每个主机的请求不超过5个则可以将该异步请求添加到正在执行的异步请求队列中，并通过一个线程池去执行该Runnable。否则，就将当前请求添加到等待的异步请求队列中。

接下来我们来分析一下线程池执行该Runnable的过程，首先来看下该线程池。

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

同步方法构造单例对象executorService，然后调用了线程池的execute来运行Runnable，那实际就是执行Runnable的run方法，跟踪代码：

final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      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 {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

进来之后并没有发现run方法，那么肯定在父类中，我们来继续看NamedRunnable

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

这是一个抽象类，run中的关键方法execute调用了一个抽象方法，那么实现还是在子类中，我们返回到AsyncCall 中看execute方法。

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

这个方法在上面已经贴过了，为了便于分析代码跟踪流程和实际代码，这里再贴一遍。

注意：execute方法执行位置是在run方法中，已经在子线程中了。getResponseWithInterceptorChain这个有关拦截器链的方法我们同样留到后续讲解。
responseCallback.onResponse(RealCall.this, response);成功回调执行的方法。

最后finally同样执行了 client.dispatcher().finished(this);是否似曾相识，没错，同步方法时也是执行了这个方法，真的是吗？其实不是，只是同步方法的一个重载方法，两者参数一个是RealCall（同步），一个是AsyncCall（异步，这是个Runnable）。跟踪代码：

/** Used by {@code AsyncCall#run} to signal completion. */
  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();
    }
  }

同步方法时promoteCalls为false，而异步方法为true，其他部分和同步方法执行一致，那么我们单独来看if (promoteCalls) promoteCalls();promoteCalls()这个方法调整了我们异步请求的队列。

后续会有OkHttp中非常重要的调度器Dispatcher和拦截器的介绍。