okHttp3 源码分析

一， 前言

在上一篇博客OkHttp3 使用详解里，我们已经介绍了 OkHttp 发送同步请求和异步请求的基本使用方法。

OkHttp 提交网络请求需要经过这样四个步骤：

1. 初始化 OkHttpClient
2. 创建 Request
3. 创建 Call 对象（okHttpClient.newCall(request)）
4. 通过 call.excute 来发送同步请求，通过 call. enqueue 来发送异步请求

二，源码分析

虽然 OkHttp 发送同步和异步请求的步骤非常类似，但是实际上它们之间的内部实现是有很大区别的。

下面根据 OkHttp 提交请求的这四个步骤来具体来分析一下 OkHttp 的内部流程

1.1 同步请求的流程源码分析

OkHttpClient

首先看一下 OkHttpClient 的构造方法，OkHttpClient 是通过 Builder 模式来创建实例对象的。

Builder 模式常常用来复杂对象的构造，通过使用 Builder 模式可以减少构造器或方法调用传入的参数数量。这对有很多个配置参数进行初始化的对象来说尤其适用。

注意：OkHttp 官方文档建议使用单例模式来创建 OkHttpClient ，因为每一个OkHttpClient 都有自己单独的连接池和线程池，复用连接池和线程池能减少延迟、节省内存。

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

OkHttpClient(OkHttpClient.Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    this.protocols = builder.protocols;
    this.connectionSpecs = builder.connectionSpecs;
    this.interceptors = Util.immutableList(builder.interceptors);
    this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
    this.eventListenerFactory = builder.eventListenerFactory;
    this.proxySelector = builder.proxySelector;
    ...
}
public static final class Builder {
        Dispatcher dispatcher;  //调度器
        @Nullable
        Proxy proxy;  //代理类，默认有三种代理模式DIRECT(直连),HTTP（http代理）,SOCKS（socks代理）
        List<Protocol> protocols;  //协议集合，协议类，用来表示使用的协议版本，比如`http/1.0,`http/1.1,`spdy/3.1,`h2等

        List<ConnectionSpec> connectionSpecs;  //连接规范，用于配置Socket连接层。对于HTTPS，还能配置安全传输层协议（TLS）版本和密码套件

        final List<Interceptor> interceptors = new ArrayList();  //拦截器，可以监听、重写和重试请求等
        final List<Interceptor> networkInterceptors = new ArrayList();
        okhttp3.EventListener.Factory eventListenerFactory;
        ProxySelector proxySelector; //代理选择类，默认不使用代理，即使用直连方式，当然，我们可以自定义配置，以指定URI使用某种代理，类似代理软件的PAC功能。

        CookieJar cookieJar;  //Cookie的保存获取
        @Nullable
        Cache cache;  //缓存类，内部使用了DiskLruCache来进行管理缓存，匹配缓存的机制不仅仅是根据url，而且会根据请求方法和请求头来验证是否可以响应缓存。此外，仅支持GET请求的缓存。

        @Nullable
        InternalCache internalCache;  //内置缓存
        SocketFactory socketFactory;  //Socket的抽象创建工厂，通过createSocket来创建Socket

        @Nullable
        SSLSocketFactory sslSocketFactory;  //安全套接层工厂，HTTPS相关，用于创建SSLSocket。一般配置HTTPS证书信任问题都需要从这里着手。对于不受信任的证书一般会提示
javax.net.ssl.SSLHandshakeException异常。

        @Nullable
        CertificateChainCleaner certificateChainCleaner;  //证书链清洁器，HTTPS相关，用于从[Java]的TLS API构建的原始数组中统计有效的证书链，然后清除跟TLS握手不相关的证书，提取可信任的证书以便可以受益于证书锁机制。

        HostnameVerifier hostnameVerifier;  //主机名验证器，与HTTPS中的SSL相关，当握手时如果URL的主机名不是可识别的主机，就会要求进行主机名验证

        CertificatePinner certificatePinner;  // 证书锁，HTTPS相关，用于约束哪些证书可以被信任，可以防止一些已知或未知的中间证书机构带来的攻击行为。如果所有证书都不被信任将抛出SSLPeerUnverifiedException异常。

        Authenticator proxyAuthenticator;  //身份认证器，当连接提示未授权时，可以通过重新设置请求头来响应一个新的Request。状态码401表示远程服务器请求授权，407表示代理服务器请求授权。该认证器在需要时会被RetryAndFollowUpInterceptor触发。

        Authenticator authenticator;
        ConnectionPool connectionPool;  //连接池
        Dns dns;  //域名解析系统
        boolean followSslRedirects;  //是否遵循SSL重定向
        boolean followRedirects;  //是否重定向
        boolean retryOnConnectionFailure;  //失败是否重新连接
        int connectTimeout;  //连接超时
        int readTimeout;     //读取超时
        int writeTimeout;    //写入超时
        int pingInterval; //与WebSocket有关，为了保持长连接，我们必须间隔一段时间发送一个ping指令进行保活；

	public Builder() {
		this.dispatcher = new Dispatcher();
		this.protocols = OkHttpClient.DEFAULT_PROTOCOLS;  //默认支持的协议
		this.connectionSpecs = OkHttpClient.DEFAULT_CONNECTION_SPECS;   //默认的连接规范
		this.eventListenerFactory = EventListener.factory(EventListener.NONE);
		this.proxySelector = ProxySelector.getDefault();  //默认的代理选择器，直连
		this.cookieJar = CookieJar.NO_COOKIES;  //默认不进行管理Cookie
		this.socketFactory = SocketFactory.getDefault();
		this.hostnameVerifier = OkHostnameVerifier.INSTANCE; //主机验证
		this.certificatePinner = CertificatePinner.DEFAULT;  //证书锁，默认不开启
		this.proxyAuthenticator = Authenticator.NONE;  //默认不进行授权
		this.authenticator = Authenticator.NONE;
		this.connectionPool = new ConnectionPool();  //连接池
		this.dns = Dns.SYSTEM;
		this.followSslRedirects = true;
		this.followRedirects = true;
		this.retryOnConnectionFailure = true;
		this.connectTimeout = 10000;
		this.readTimeout = 10000;
		this.writeTimeout = 10000;
		this.pingInterval = 0;
	}
	...
}

dispatcher：请求分发器。后面会详细解释

eventListenerFactory ：Call的状态监听器，注意这个是okhttp新添加的功能

hostnameVerifier、 certificatePinner、 proxyAuthenticator、 authenticator：都是安全相关的设置

connectionPool：连接池，我们通常将一个客户端和服务端和连接抽象为一个 connection，而每一个 connection 都会被存放在 connectionPool 中，由它进行统一的管理，例如有一个相同的 http 请求产生时，connection 就可以得到复用

Request

Request 同样也是使用了 Builder 模式来配置 head、method 等等的参数

public final class Request {

 ...

  Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tags = Util.immutableMap(builder.tags);
  }
  ...

  public static class Builder {
    HttpUrl url;
    String method;
    Headers.Builder headers;
    RequestBody body;

    public Builder() {
      this.method = "GET";
      this.headers = new Headers.Builder();
    }

    Builder(Request request) {
      this.url = request.url;
      this.method = request.method;
      this.body = request.body;
      this.tags = request.tags.isEmpty()
          ? Collections.<Class<?>, Object>emptyMap()
          : new LinkedHashMap<>(request.tags);
      this.headers = request.headers.newBuilder();
    }
    ...

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

Call

在创建了 OkHttpClient 和 Request 的实例对象之后，就可以通过调用 okHttpclient.newCall(request) 来创建一个 Call 对象了。

OkHttpClient 的 newCall 方法实际上是调用了 RealCall（Call的实现类）的 newRealCall 方法：

public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false);
}

接着跟进来看一下 RealCall.newRealCall 方法的实现

static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
}

newRealCall 方法创建了一个 RealCall 的实例，同时还赋值了一个Listener，然后就返回了

接着看一下 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 重定向拦截器。

到目前为止，Call 对象就被 okHttpClient 的 newCall 方法给创建完成了，接下来我们就走到了第四步，通过调用 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，这表示说同一个 http 同步请求只能执行一次

接着来看一下 execute 方法最关键的地方：

client.dispacher().executed(this);

client.dispacher() 方法返回了一个 dispatcher 对象，然后接着调用了 dispacher 对象的 executed 方法来发送同步请求

Dispatcher#executed：

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

也就是说一个同步请求实际上只是调用了 executed() 方法来把一个同步任务添加到了 runningSyncCalls 队列之中。

在将任务添加到队列之后，就调用了 getResponseWithInterceptorChain() 方法来获取 Response，在方法内部会依次调用拦截器来进行相应的操作。

最后，在 finally 代码块中会调用 dispatcher 的 finished() 方法来将一个请求从请求队列中移除

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(); //同步请求时为 false，不会触发该方法，但异步请求时触发
    runningCallsCount = runningCallsCount(); //返回正在执行的异步请求和同步请求的总数量
    idleCallback = this.idleCallback;
  }

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

至此，同步请求的流程就结束了，其实在同步请求中 dispatcher 所做的工作很简单，只有保存同步请求和移除同步请求。

1.2 异步请求流程源码分析

与前面同步请求不同，Okhttp 通过调用 Call 对象的 enqueue 来实现异步的网络请求

@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 方法的前部分与 同步请求的 executed 方法相同，都是使用一个标志位 executed 来判断当前的 RealCall 对象是否已被执行过，如果已被执行过，则会抛出异常。

最后会调用 dispatcher 的 enqueue 方法来处理异常请求，注意到 enqueue 方法传入了一个 封装了响应回调 callBack 的 AsyncCall 对象，AsyncCall 是 Runnable 的一个实现类。

2. Dispatcher

通过上面的分析，我们已经了解了OkHttp 同步请求和异步请求的实现流程，同时也知道了实际的同步/异步请求都是有 dispatcher 这个分发器类来完成的。

client.dispatcher().executed(this);    //同步请求
client.dispatcher().enqueue(new AsyncCall(responseCallback));    //异步请求

OkHttpClient 的 dispatcher 方法仅仅是返回了一个 dispatcher 对象

public Dispatcher dispatcher() {
  return dispatcher;
}

细心的朋友可能还记得，dispatcher 是在 OkHttpClient 的 Builder 方法中初始化的

public Builder() {
  dispatcher = new Dispatcher();
  protocols = DEFAULT_PROTOCOLS;
  connectionSpecs = DEFAULT_CONNECTION_SPECS;
  eventListenerFactory = EventListener.factory(EventListener.NONE);
  proxySelector = ProxySelector.getDefault();
  cookieJar = CookieJar.NO_COOKIES;
  ...

之前我们已经知道了 dispatcher.executed 同步方法的作用就是把一个同步任务添加到 runningSyncCalls 队列之中，接着我们就可以来看一下 dispatcher.enqueue 异步方法具体是怎么实现的

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

  /** Executes calls. Created lazily. */
  private @Nullable 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<>();
  ...

  synchronized void enqueue(AsyncCall call) {
    //判断 runningAsyncCalls 请求队列中的 AsyncCall（即Runnable） 的数量是否大于默认的最大并发请求数（默认为64）
    //判断 正在运行的主机请求数是否大于默认的每个主机的最大请求数（默认为5）
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      //当满足条件时，则把 异步请求Runable（AsyncCall）添加到 runningAsyncCalls 异步队列中
      runningAsyncCalls.add(call);
	  //通过线程池来执行请求 call
      executorService().execute(call);
    } else {
	  //否则加入到等待队列中
      readyAsyncCalls.add(call);
    }
  }
  ...

    /** Returns the number of running calls that share a host with {@code call}. */
  private int runningCallsForHost(AsyncCall call) {
    int result = 0;
    for (AsyncCall c : runningAsyncCalls) {
      if (c.get().forWebSocket) continue;
      if (c.host().equals(call.host())) result++;
    }
    return result;
  }

}

在了解了 call 请求会被添加到请求队列里之后，我们再来分析一下线程池是如何执行请求的

可以看到在 executorService() 这个方法中创建了一个 ThreadPoolExecutor 的单例

  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 方法，也就是说最终会调用线程池中每一个线程的 run 方法，也就是传入该方法的 AsyncCall 对象的 run() 方法，但是我们查看源码发现 AsyncCall 中并没有 run 方法，不过同时也发现 AsyncCall 继承自 NamedRunnable， NamedRunnable 的 run() 方法调用了 execute() 这个抽象方法，而 AsyncCall 实现了 execute() 这个抽象方法。

/**
 * Runnable implementation which always sets its thread name.
 */
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 的 execute 方法才是真正实现操作的地方

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 对象，并根据情况调用 callBack 的回调方法
      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 {
      //finished 方法的作用在上面介绍同步请求的地方介绍过了
      client.dispatcher().finished(this);
    }
  }
}

这里最后一步 finished 的作用在上面同步请求的地方也用到了，这里再详细介绍一下

/**
* @params calls 同步请求时传入 runningSyncCalls ，异步请求是传入的为 runningAsyncCalls
* promoteCalls 同步请求时传入false，异步时传入true
*/
private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
	int runningCallsCount;
	Runnable idleCallback;
	synchronized(this) {
		//将当前 call 请求从请求队列中删除
		if (!calls.remove(call)) {
			throw new AssertionError("Call wasn't in-flight!");
		}
		//遍历 runningAsyncCalls 接下来的 call，并通过 executorService 执行
		if (promoteCalls) {
			this.promoteCalls();
		}
		//重新计算正在执行的线程数量
		runningCallsCount = this.runningCallsCount();
		idleCallback = this.idleCallback;
	}

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

}

到此我们就经历了一次完整的同步/异步网络请求了。

参考：

https://blog.csdn.net/json_it/article/details/78404010

https://blog.csdn.net/lintcgirl/article/details/52213570

https://www.jianshu.com/p/e3b6f821acb8