OkHttp3源码思路分析

 1.源码思路

        本文主要分析OkHttp3中的主干逻辑，不做详尽的解说。OkHttp3有以下几个核心类OkHttpClitent、Request、Response、RealCall、Interceptor、RealInterceptorChain。通过OkHttpClient.Builder类构建OkHttpClitent对象，OkHttpClitent对象中使用RealCall类和传入的Request对象进行同步或异步请求，请求发出前通过一系列拦截器Interceptor处理（重点），最后通过Response对象返回网络请求结果。

2.OkHttpClient

        OkHttpClient是整个OkHttp框架的核心管理类，所有内部的逻辑都由OkHttpClient管理，通过Builder构造器创建，我们大概了解一下里面的属性。

public Builder() {
    // dispatch。负责分配处理异步任务
    this.dispatcher = new Dispatcher();
    // 支持的协议，默认支持http2和http1.1
    this.protocols = OkHttpClient.DEFAULT_PROTOCOLS;
    // 指定socket链接配置。默认：MODERN_TLS和CLEARTEXT
    this.connectionSpecs = OkHttpClient.DEFAULT_CONNECTION_SPECS;
    // 监听http请求过程中涉及的各种事件。包括：开始请求、dns解析开始/结束、链接开始等等。默认是的Listener
    this.eventListenerFactory = EventListener.factory(EventListener.NONE);
    // 设置代理
    this.proxySelector = ProxySelector.getDefault();
    // 设置cookie
    this.cookieJar = CookieJar.NO_COOKIES;
    // 设置创建Socket链接的Factory
    this.socketFactory = SocketFactory.getDefault();
    // 验证域名和证书的域名是否匹配
    this.hostnameVerifier = OkHostnameVerifier.INSTANCE;
    // 设置信任的证书，不信任之外的证书，默认是空的
    this.certificatePinner = CertificatePinner.DEFAULT;
    // 与身份认证有关。详见：https://square.github.io/okhttp/3.x/okhttp/okhttp3/Authenticator.html
    this.proxyAuthenticator = Authenticator.NONE;
    // 与身份认证有关。详见：https://square.github.io/okhttp/3.x/okhttp/okhttp3/Authenticator.html
    this.authenticator = Authenticator.NONE;
    // 连接池-缓存链接和清理空闲的连接
    this.connectionPool = new ConnectionPool();
    // 域名解析
    this.dns = Dns.SYSTEM;
    // 是否支持ssl重定向
    this.followSslRedirects = true;
    // 是否支持重定向
    this.followRedirects = true;
    // 失败后是否重试
    this.retryOnConnectionFailure = true;
    // 链接超时时间
    this.connectTimeout = 10000;
    // 读超时时间
    this.readTimeout = 10000;
    // 写超时时间
    this.writeTimeout = 10000;
    // ping的时间间隔。如果使用WebSocket请求设置pingInterval，以保活
    this.pingInterval = 0;
}

这些属性大概了解一下就行，我们继续往后分析

3.Request和Response

        Request和Response对象都是通过Builder创建，Request是我们发送请求封装类，内部有url, header , method，body等常见的参数，Response是请求的结果，包含code, message, header,body ；这两个类的定义是完全符合Http协议所定义的请求内容和响应内容。下面是这两个类对应的属性，了解一下。

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

  Response(Builder builder) {
    this.request = builder.request;
    this.protocol = builder.protocol;
    this.code = builder.code;
    this.message = builder.message;
    this.handshake = builder.handshake;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.networkResponse = builder.networkResponse;
    this.cacheResponse = builder.cacheResponse;
    this.priorResponse = builder.priorResponse;
    this.sentRequestAtMillis = builder.sentRequestAtMillis;
    this.receivedResponseAtMillis = builder.receivedResponseAtMillis;
  }

4.RealCall

        RealCall负责请求的调度（同步的话走当前线程发送请求，异步的话则使用OkHttp内部利用ExecutorService实现的线程池进行）；同时负责构造内部逻辑责任链，并执行责任链相关的逻辑，直到获取结果。虽然OkHttpClient是整个OkHttp的核心管理类，但是真正发出请求并且组织逻辑的是RealCall类，它同时肩负了调度和责任链组织的两大重任，接下来我们来着重分析下RealCall类的逻辑（重点getResponseWithInterceptorChain()方法）

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

  @Override 
  public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    // 此处实际上调用的也是execute()方法
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

  // 重点分析
  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, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

        RealCall类并不复杂，有两个最重要的方法，execute() 和 enqueue()，一个是处理同步请求，一个是处理异步请求。跟进enqueue的源码后发现，它只是通过异步线程和callback做了一个异步调用的封装，最终逻辑还是会调用到execute()这个方法，然后调用了getResponseWithInterceptorChain()获得请求结果。

        看来是 getResponseWithInterceptorChain() 方法承载了整个请求的核心逻辑，那么只需要把这个方法分析清楚了，整个OkHttp的请求流程就大体搞明白了，从源码可以看到，即使是 getResponseWithInterceptorChain() 方法的逻辑其实也很简单，它生成了一个Interceptors拦截器的List列表，然后创建了一个叫RealInterceptorChain的类，最后的Response就是通过chain.proceed获取到的（重点chain.proceed方法）。

5.Interceptor

上面分析到拦截器，Interceptors拦截器List加入顺序依次是：

        1.client.Interceptors  ------  应用拦截器，OkHttpClient.Builder构建时候添加的拦截器列表。不需要担心中间过程的响应，如重定向和重试；总是只调用一次,即使HTTP响应是从缓存中获取；观察应用程序的初衷. 不关心OkHttp注入的头信息如: If-None-Match；允许短路而不调用 Chain.proceed(),即中止调用；允许重试,使 Chain.proceed()调用多次。

        2.RetryAndFollowUpInterceptor  ------  负责okhttp请求失败的恢复和重定向

        3.BridgeInterceptor  ------  添加必要的请求头部信息，gzip处理等

        4.CacheInterceptor  ------  负责缓存的逻辑

        5.ConnectInterceptor  ------  连接服务，负责和服务器建立连接 这里才是真正的请求网络

        6.client.networkInterceptors  ------  网络拦截器，OkHttpClient.Builder构建时候添加的拦截器列表。能够操作中间过程的响应,如重定向和重试；当网络短路而返回缓存响应时不被调用；只观察在网络上传输的数据；携带请求来访问连接。

        7.CallServerInterceptor  ------  执行流操作(写出请求体、获得响应数据) 负责向服务器发送请求数据、从服务器读取响应数据 进行http请求报文的封装与请求报文的解析，CalllServerInterceptor是最后一个拦截器，前面的拦截器已经完成了socket连接和tls连接，那么这一步就是传输http的头部和body数据了。

6.RealInterceptorChain

        通过前面的分析可知，RealCall将Interceptors一个一个添加到List之后 ，就构造生成了一个RealInterceptorChain对象，并调用chain.proceed获得响应结果。那么就来分析下chain.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, call, eventListener, connectTimeout, readTimeout,
        writeTimeout);
    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");
    }

    if (response.body() == null) {
      throw new IllegalStateException(
          "interceptor " + interceptor + " returned a response with no body");
    }

    return response;
  }

        通过进一步分析RealInterceptorChain和Interceptors，我们得到了一个结论，OkHttp将整个请求的复杂逻辑切成了一个一个的独立模块并命名为拦截器(Interceptor)，通过责任链的设计模式串联到了一起，最终完成请求获取响应结果。

7.流程图