Android面试相关 - Okhttp3源码分析

implementation ‘com.squareup.okhttp3:okhttp:3.11.0’

背景

之前的底层网络库基本就是Apache HttpClient和HttpURLConnection。由于HttClient比较难用，官方在Android2.3以后就不建议用了，并且在Android5.0以后废弃了HttpClient，在Android6.0更是删除了HttpClient。
HttpURLConnection是一种多用途、轻量极的HTTP客户端，使用它来进行HTTP操作可以适用于大多数的应用程序，但是在Android 2.2版本之前存在一些bug，所以官方建议在Android2.3以后替代HttpClient，Volley就是按版本分区使用这两个网络库。
然而随着开源届扛把子Square的崛起，OkHttp的开源，这两个网络库只能被淹没在历史洪流中。Android4.4以后HttpURLConnection的底层已经替换成OkHttp实现。OkHttp配合同样是Square开源的Retrofit，网络请求变得更简便，功能更强大。

介绍

OkHttp是一个现代，快速，高效的网络库，OkHttp 库的设计和实现的首要目标是高效。
1.支持 HTTP/2和SPDY，这使得对同一个主机发出的所有请求都可以共享相同的套接字连接；
2.如果 HTTP/2和SPDY不可用，OkHttp会使用连接池来复用连接以提高效率。
3.支持Gzip降低传输内容的大小
4.支持Http缓存
以上均是摘抄别人的东西

简单使用

   //创建OkHttpClient 对象
   OkHttpClient client = new OkHttpClient();
   //创建request
   Request request = new Request.Builder()
                 .url("")
                 .build();
   //创建请求对象
   Call call = okHttpClient.newCall(request);
   //发起同步请求
   try {
       Response execute = call.execute();
   } catch (Exception e) {
       e.printStackTrace();
   }
   //发起异步请求
   call.enqueue(new Callback() {
      @Override
      public void onFailure(Call call, IOException e) {

      }

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

      }
 });

源码分析

第一步：创建OkHttpClient对象

   OkHttpClient client = new OkHttpClient();

    //另一种方法是通过Builder创建
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    //可以设置一些builder，如设置连接超时时间
    builder.connectTimeout(5000, TimeUnit.SECONDS);
    //初始化OkhttpClient完成
    OkHttpClient okHttpClient = builder.build();

首先我们点击创建的 OkHttpClient 对象进去源码是这样的：

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

然后是走了有参构造：

  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.proxySelector = builder.proxySelector;
    this.cookieJar = builder.cookieJar;
    this.cache = builder.cache;
    this.internalCache = builder.internalCache;
    this.socketFactory = builder.socketFactory;

    boolean isTLS = false;
    for (ConnectionSpec spec : connectionSpecs) {
      isTLS = isTLS || spec.isTls();
    }

    if (builder.sslSocketFactory != null || !isTLS) {
      this.sslSocketFactory = builder.sslSocketFactory;
      this.certificateChainCleaner = builder.certificateChainCleaner;
    } else {
      X509TrustManager trustManager = systemDefaultTrustManager();
      this.sslSocketFactory = systemDefaultSslSocketFactory(trustManager);
      this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
    }

    this.hostnameVerifier = builder.hostnameVerifier;
    this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(
        certificateChainCleaner);
    this.proxyAuthenticator = builder.proxyAuthenticator;
    this.authenticator = builder.authenticator;
    this.connectionPool = builder.connectionPool;
    this.dns = builder.dns;
    this.followSslRedirects = builder.followSslRedirects;
    this.followRedirects = builder.followRedirects;
    this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
    this.connectTimeout = builder.connectTimeout;
    this.readTimeout = builder.readTimeout;
    this.writeTimeout = builder.writeTimeout;
    this.pingInterval = builder.pingInterval;
  }

可以看到有很多常量，这里使用了建造者模式，所以这些常量可以通过 build() 进行配置。如果不进行配置则使用无参构造中传进来的默认配置，每个常量的意思具体如下：

    public Builder() {
      // 分发器Dispatcher对象
      dispatcher = new Dispatcher(); 
      // 协议集合，默认协议集合包括HTTP2,HTTP_1_1 
      protocols = DEFAULT_PROTOCOLS;    
      // 传输层版本和连接协议
      connectionSpecs = DEFAULT_CONNECTION_SPECS;
      // 代理选择器
      proxySelector = ProxySelector.getDefault();
      // Cookie瓶，为HTTP的cookies提供策略和持久化
      cookieJar = CookieJar.NO_COOKIES;
      // socket工厂类
      socketFactory = SocketFactory.getDefault();
      // 主机名字确认
      hostnameVerifier = OkHostnameVerifier.INSTANCE;
      // 证书链
      certificatePinner = CertificatePinner.DEFAULT;
      // 代理服务器身份验证
      proxyAuthenticator = Authenticator.NONE;
      // 源服务器身份验证
      authenticator = Authenticator.NONE;
      // 连接池
      connectionPool = new ConnectionPool();
      // 域名
      dns = Dns.SYSTEM;
      // 是否遵循 ssl 重定向
      followSslRedirects = true;
      // 是否遵循重定向
      followRedirects = true;
      // 连接失败的时候是否重试  
      retryOnConnectionFailure = true;
      // 连接超时
      connectTimeout = 10_000;
      // 读取超时
      readTimeout = 10_000;
     // 写入超时
      writeTimeout = 10_000;
      // HTTP / 2 和 Web 套接字 ping 之间的时间间隔
      pingInterval = 0;
    }

第二步：创建Request对象

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

可以看到，这里同样使用了建造者模式，我们点击 Request 进去看看：

  final HttpUrl url;
  final String method;
  final Headers headers;
  final RequestBody body;
  final Object tag;

Request只是用来设置一些请求链接（url）、请求方法（method）、请求头（headers）、请求体（body）、标签（tag，可作为取消请求的标记）。

第三步：创建请求对象Call

   Call call = okHttpClient.newCall(request);

首先我们点进newCall()方法里去看一下：

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

发现调用的的是RealCall类里面的newRealCall()方法，并传入了了okttpclient和request。
再跟进到newRealCall()方法：

 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 对象，并返回给上一层。RealCall 是 Call 的实现类，Call 定义了请求相关的操作，例如同步异步、取消请求等方法。所以后续的请求相关操作基本都是在调用 Call 定义的方法，而这些方法真正的执行是它的实现类 RealCall。

最后看看 RealCall 的构造函数，该函数是比较简单的，只是赋值一些常量，然后创建了重试与重定向拦截器（RetryAndFollowUpInterceptor）（这个后面会讲）：

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

到这之后我们就可以去发起请求了，像上面的简单使用，可以发起同步请求execute()，或者发起异步请求enqueue()，下面首先说一下同步请求，比较简单，之后再说异步请求。

第四步：同步请求

 Response execute = call.execute();

点进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表示一个okhttp请求只能运行执行一次

 synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }

接着往下看真正调用请求的是这个方法,分发器的excuted()方法：

      client.dispatcher().executed(this);

点进去会发现调的是Dispatcher类executed()方法，先来看一下Dispatcher，主要是有以下里面的东西：

  //最大请求数是64
  private int maxRequests = 64;
  //最大主机连接数是5
  private int maxRequestsPerHost = 5;
  //线程池
  private @Nullable ExecutorService executorService;
  //准备执行的异步任务队列
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
  //正在执行的异步任务队列
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
  //正在执行的同步任务队列
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

看完Dispatcher类，继续来看executed()方法：

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

里面的add()方法是将同步请求任务添加到同步请求队列中。

下面就到了最重要的一步，获取请求结果的方法：

      Response result = getResponseWithInterceptorChain();

进入到方法里去看一下：

  Response getResponseWithInterceptorChain() throws IOException {
    // 创建一个拦截器集合,
    List<Interceptor> interceptors = new ArrayList<>();
    //添加用户自定义的interceptors
    interceptors.addAll(client.interceptors());
    //添加retryAndFollowUpInterceptor拦截器，主要负责请求失败重试
    interceptors.add(retryAndFollowUpInterceptor);
    /** 
     *    添加桥拦截器,设置请求头内容类型、长度、编码。添加cookie，设置其他报头，如User-Agent,Host,Keep-alive等。其中 
     *    Keep-Alive是实现多路复用的必要步骤设置gzip压缩，并在接收到内容后进行解压。省去了应用层处理数据解压的麻烦
     */    
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
     // 添加缓存拦截器，主要负责cache管理
    interceptors.add(new CacheInterceptor(client.internalCache()));
    // 添加连接拦截器，负责获取连接
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
     // 添加用户自定义的网络拦截器
      interceptors.addAll(client.networkInterceptors());
    }
    // 添加服务器请求拦截器，负责向服务器发起真正的网络请求，并接收到服务器响应以后返回请求结果。
    interceptors.add(new CallServerInterceptor(forWebSocket));
    //  构建责任链，通过拦截器构造Interceptor.Chain，其真正实现是RealInterceptorChain
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());
    // 处理责任链中的拦截器，通过拦截器链的proceed（）方法获取请求结果
    return chain.proceed(originalRequest);
  }

可以看到，这里用到了很多拦截器，将这些拦截器构建成一条责任链，然后再一个个处理。这里用到了责任链模式，每个拦截器负责相应的功能，上一个拦截器完成会传给下一个拦截器，直到最后一个拦截器执行完再一层层向上返回 Response。
接下来点进proceed()方法看一下：

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

这里会构建一个新的责任链，然后把责任链的索引加 1（为了下次从拦截器集合中取出下一个拦截器），接着从拦截器集合中取出当前拦截器并调用 intercept() 方法，这样如果这个拦截器可以完成任务会马上返回 Response，否则会在 intercept() 方法中继续处理责任链，因为该 intercept() 方法中会继续调用责任链的 proceed() 方法。通过责任链模式，循环调用，最终获取请求结果。

获取结果后还会去调用finished()方法，是在在finally中执行的：

      client.dispatcher().finished(this);

点进去是这样的：

  void finished(RealCall call) {
    //注意传递的是哪个队列，注意boolen值,一个是同步用到的，一个是异步用到的
    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();
    }
  }

calls.remove(call) 只是把当前 RealCall 从正在运行的同步请求队列中移除了，说明请求已经完成了。
到这里同步请求的分析就已经完了，下面分析一下异步请求的流程。

第五步：异步请求

 call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

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

            }
        });

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

前几步和同步请求的一样，我们只需要关注一行代码就可以了：

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

这个方法大概就是这样，正在运行的异步请求队列数“ 小于 ”最大并发请求数“，并且 ”每个主机正在运行的请求数“ 小于 ”每个主机最大请求数“，则将当前请求继续加入 ”正在运行的异步请求队列“ 并在线程池中执行，否则将当前请求加入 ”准备中的异步请求队列“。
我们看到线程池中还传了一个 AsyncCall 进去，点击进去看看：

 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();
       /**
          *  判断重定向和重试拦截器是否取消，如果取消，调用responseCallback的onFailure回调，responseCallback就是我们通过          
          *  enqueue方法传入的Callback对象。如果没取消，调用responseCallback的onResponse回调。
          */
        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);
      }
    }
  }

我们发现AsyncCall继承自NamedRunnable，而NamedRunnable实现了Runnable，并且是在NamedRunnable执行了run方法,在这个run()方法中执行了excute()方法也就是AsyncCall中的那个excute()方法。这个excute()方法就不多说了，就是获取请求结果，相信大家一定能看的懂。最后讲一下这个方法：

        client.dispatcher().finished(this);

点进去看一下和同步请求的有什么不同：

 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方法内部会将本次的异步请求RealCall从正在请求的异步请求队列中移除，由于promoteCalls传入的是true，接着调用promoteCalls()方法。
进到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.
    }
  }

这个里面做的就是，循环从readyAsyncCalls中取出任务，然后将该任务放到runningAsyncCalls中，最后再调用调用executorService().execute(call)执行任务。

到这里就结束了，历时一周，经过东拼西凑终于是写完了这篇帖子，发现问题的，大家可以留在评论里指出，我在进行修改。

最后，感觉对大家有用的，可以点一下关注，会不定时分享一些安卓相关的知识点。