OKHttp原码分析(一)

一，概述

okhttp并不是对某个网络请求类的封装，它是偏底层的网络请求类库，封装的是传输层的socket，与httpURLconnection是同一级别的。OKHttp比起httpURLconnection做了大量的性能优化和在使用上的优化，因此OKHttp的源码也比较复杂，需要连续多篇blog进行讲解分析。

这篇blog以get请求为例主要分析以下几点：
1，OkHttpClient对象的创建。
2，Request 对象的创建。
3，Call对象的创建
4，Call的execute方法实现同步请求。
5，Call的enqueue方法实现异步请求，异步请求是怎么开启的子线程。
6，同步请求与异步请求是怎么殊途同归到一条路上的。

二，OkHttpClient对象的创建

OKHttpClient对象的创建方式有两种。
第一种是使用构造方法创建对象：

OkHttpClient client = new OkHttpClient();//使用构造方法直接创建OkHttpClient对象。

第二种是使用Builder模式创建对象：

OkHttpClient.Builder builder = new OkHttpClient.Builder();//先创建构建者对象
 builder.connectTimeout(3*1000, TimeUnit.MILLISECONDS);//设置超时时间
 OkHttpClient client = builder.build();//使用构建者创建OkHttpClient对象。

1，使用构造方法创建OkHttpClient对象

OkHttpClient的构造方法原码是：

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

本质调用的是OkHttpClient的有参构造，我们先看看这个构造方法的源码，再看Builder类的无参构造方法。

OkHttpClient的有参构造方法的部分原码是

private OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.protocols = builder.protocols;
    this.interceptors = Util.immutableList(builder.interceptors);
    this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
    this.cookieJar = builder.cookieJar;
    this.cache = builder.cache;
    this.internalCache = builder.internalCache;
    this.socketFactory = builder.socketFactory;
    。。。略。。。
}

以上是部分代码，从代码中我们可以看出这个构造方法主要是给OkHttpClient的字段进行初始化，OkHttpClient字段的值来自于builder对象。

下面看Builder类的无参构造方法的源码：

public Builder() {
  dispatcher = new Dispatcher();
  socketFactory = SocketFactory.getDefault();//得到SocketFactory对象，这个工程类可以创建Socket对象。
  connectionPool = new ConnectionPool();//链接池
  connectTimeout = 10_000;//设置连接超时时间，默认为10秒
  readTimeout = 10_000;//设置读取超时时间
  writeTimeout = 10_000;//设置写入超时时间
    。。。略。。。
}

Builder的无参构造中主要是对Builder的字段进行初始化，这些初始化值也是OkHttpClient的初始化值，也就是对网络请求参数的初始化。

2，使用Builder模式创建OkHttpClient对象

首先看创建Builder对象使用的代码：

OkHttpClient.Builder builder = new OkHttpClient.Builder();

Builder是OkHttpClient的内部类，创建Builder对象使用的是builder的无参构造方法。在上面我们已经看过Builder的无参构造方法，主要功能就是进行一些字段的初始化。

创建OkHttpClient对象使用的代码是：

 OkHttpClient client = builder.build();

这是一种build设计模式，下面看Builder类的build方法的源码：

    public OkHttpClient build() {
      return new OkHttpClient(this);
    }

看到这儿会觉得好熟悉啊，build()方法中调用的也是OkHttpClient的有参构造，参数也是Builder对象。通过上面的分析我们知道OkHttpClient的有参构造主要作用就是给OkHttpClient的字段进行初始化。

3，两种创建OkHttpClient对象方式的区别与应用场景

通过上述分析可知，创建OkHttpClient对象最终都是使用的OkHttpClient的有参构造，且都是通过Builder对象给OkHttpClient的字段进行初始化。

区别是：
1，使用构造方法创建OkHttpClient对象：使用builder的无参构造方法创建builder对象后直接给OkHttpClient的字段进行初始化，即这是一步操作，中间不能做任何设置。
2，使用Builder模式创建OkHttpClient对象：先得到Builder对象，然后再通过代码创建OkHttpClient对象对象。这样我们就可以根据需要修改Builder对象的一些字段值。

应用场景：
在Builder的无参构造方法中我们看到系统对连接超时时间，缓存等字段初始化了一些默认值，如果这些值不是我们想要的，我们要修改某些值，此时就需要使用第二种方法创建OkHttpClient对象。如果系统的默认值满足我们的要求，直接使用第一种方法创建OkHttpClient对象即可。

三，Request 对象的创建

get请求时创建Request 对象的代码如下：

Request request = new Request.Builder()
                            .url("http://www.baidu.com")
                            .build();

很明显这是一种Builder设计模式，首先创建Builder对象，然后给builder对象设置属性，然后再通过Builder对象的build方法创建Request 对象，并把builder的值赋给Request 对象。

注意：这个Builder类是Request 的内部类，与OkHttpClient的内部类Builder不是同一个。

下面看Request 的内部类Builder的无参构造原码：

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

此时发现在创建Builder对象时默认把请求方式设置为GET，所以使用get请求不需要再次设置请求方式。
此外还有一行代码是创建headers 。这是headers 的使用细节，这儿不做讲解。

下面看Builder的url方法的原码。
url方法有三个重载方法，最终调用的都是下面这个方法：

    public Builder url(HttpUrl url) {
      if (url == null) throw new NullPointerException("url == null");
      this.url = url;
      return this;
    }

此时注意两点：
1，url方法就是给builder对象的url属性赋值。
2，此时返回this，这是一种典型的链式编程思想。

下面看Builder的build方法的原码：

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

作用就是调用Request的有参构造创建Request对象。
下面看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;
  }

这个方法的作用就是把builder的属性值赋值给Request的属性。

看到这儿我们应该对builder设计模式有个认识了。首先创建builder对象，然后给builder对象的属性赋值，然后将builder对象的属性值赋值给实际要创建的对象。

四，Call对象的创建

创建call对象使用的代码是：

client.newCall(request)

下面看一下OKHttpClient类的newCall方法的原码：

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

这个方法的作用是创建RealCall对象，并把client对象和request对象都传递过去了。

注意：
1，RealCall是Call接口的实现类，Call调用的方法的实现都在RealCall类中，这个类是关键类。
2，将client对象和request对象传递给了RealCall对象，这样等于RealCall对象拥有了client的属性值和request对象的属性值。即我们在前面对client设置的属性值和对request设置的属性值都传递到了这个对象中。

五，RealCall的execute方法实现同步请求。

通过上面分析我们知道Call是一个接口，他的实现类是RealCall，所以下面看RealCall类的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);
    }
  }

这个方法中的核心代码是：Response result = getResponseWithInterceptorChain()。这个方法中返回的result 即是我们需要的响应数据。所以getResponseWithInterceptorChain是网络请求的核心方法。现在先记住这个方法，这个方法的源码下篇blog再惊喜讲解。

六，RealCall的enqueue方法实现异步请求

首先上RealCall类的enqueue方法的源码：

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

分析：
1，这里的client就是前面创建的OKHttpClient对象。
2，client.dispatcher()方法返回Dispatcher对象，这个类成为调度着，这个对象的创建在OKHttpClient的内部类Builder的构造方法中。
3，重点有两个，一个是Dispatcher的enqueue方法，一个是AsyncCall对象。

下面先看Dispatcher的enqueue方法的源码：

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

这是一个同步方法，核心代码是：executorService().execute(call);

下面首先看executorService()方法的源码：

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

这个方法创建了一个线程池对象，这个线程池的特点是：
1，核心线程数为0。
2，最大线程数是Integer的最大值，这里可以理解为无限多。
3，非核心线程存活时间为60秒。

分析：这个线程池没有核心线程，非核心线程的存活时间只有60秒，所以这个线程池的优点不是特别突出。

下面继续看：executorService().execute(call);
executorService()返回一个线程池对象，我们知道execute方法接收Runnable对象，Runnable的run方法执行在子线程。下面开下这个call对象。

这个call对象来源于：client.dispatcher().enqueue(new AsyncCall(responseCallback));

下面看AsyncCall类。
AsyncCall类是RealCall的内部类，AsyncCall继承NamedRunnable类，NamedRunnable又继承Runnable类。在NamedRunnable类中声明了一个抽象方法execute()，且在run方法中调用了。我们由代码executorService().execute(call)知道此时会调用run方法，从而会调用execute方法。
下面看AsyncCall的execute方法的源码(注意：这个方法执行在子线程)：

@Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          responseCallback.onResponse(RealCall.this, response);
        }
      }
    }

在这个方法中我们看到了熟悉的代码：
Response response = getResponseWithInterceptorChain();
这行代码在同步请求中已经看到过，它是网络请求的核心。到此同步请求和异步请求都殊途同归到了getResponseWithInterceptorChain方法上。不同的是：异步请求是在子线程中调用的getResponseWithInterceptorChain方法。

此外在这儿我们看到了CallBack的onFailure方法和onResponse方法被调用。由于execute方法执行在子线程，所以onFailure方法和onResponse方法都是执行在子线程。

注意事项：
1，在RealCAll的enqueue方法中通过线程池的方式开启了子线程。
2，CallBack的onFailure方法和onResponse方法都执行在子线程中，所以在更新UI时还需要跳转到UI线程。

七，同步请求与异步请求是怎么殊途同归到一条路上的

由上面的分析可知无论是同步请求还是异步请求，最后调用的代码都是：
Response response = getResponseWithInterceptorChain();
这行代码是网络请求的核心，以上的代码都是辅助作用。

这行代码返回了Response 对象，所以表层的原码分析到此也算是一个结点。
getResponseWithInterceptorChain内部到底是怎么执行的，下一篇blog再做分析。