一步步带你读懂 Okhttp 源码

雨点打透心脏的1/2处 2023-09-29 20:09 3阅读 0赞

### 前言 ###

![format_png][]

okHttp， square 公司开源的网络请求神器，截止到 2019-09-02，在 Github 上面已经超过 34K 的 star，足见他的受欢迎程度。

到目前为止，他的最新版本是 4.1.0， 使用 kotlin 语言写的，由于本人对 kotlin 语言不是很熟悉，这篇文章已 3.5.0 的版本为基础进行分析。

### 简介 ###

Rxjava+Okhttp+Refrofit 如今已经成为项目网络请求的首选，在讲解原理之前，我们先来看一下 Okhttp 的基本使用。

使用 OkHttp 基本是以下四步：

1.  创建 OkHttpClient 对象
2.  创建Request请求对象
3.  创建Call对象
4.  同步请求调用call.execute()；异步请求调用call.enqueue(callback)

**同步执行**

//创建OkHttpClient对象
    OkHttpClient client = new OkHttpClient();
    
    String run(String url) throws IOException {
       //创建Request请求对象
      Request request = new Request.Builder()
          .url(url)
          .build();
    
       //创建Call对象，并执行同步获取网络数据
      Response response = client.newCall(request).execute();
      return response.body().string();
    }

**异步执行**

void runAsync(String url, Callback callback) {
        OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request();
                Request.Builder builder = request.newBuilder().addHeader("name", "test");
                return chain.proceed(builder.build());
            }
        }).build();
        //创建Request请求对象
        Request request = new Request.Builder()
                .url(url)
                .build();
    
        client.newCall(request).enqueue(callback);
    
    }

接下来我会从这四步,分析 Okhttp 的基本原理。

### OkHttpClient ###

创建 OkHttpClient 一般有两种方法，一种是直接 `new OkHttpClient()`,另外一种是通过 `OkHttpClient.Builder()`

OkhttpClient client = new OkHttpClient
                        .Builder()
                        .connectTimeout(5, TimeUnit.SECONDS)
                        .writeTimeout(10,TimeUnit.SECONDS)
                        .readTimeout(10, TimeUnit.SECONDS)
                        .build();

第二种创建方式主要是通过建造者模式，来配置一些参数，比如连接超时时间，读写超时时间，超时重试次数等。这样有一个好处，可以对外屏蔽掉构建 client 的细节。关于建造者模式的，有兴趣的可以读我的这一篇文章[建造者模式（Builder）及其应用][Builder]

### Request ###

public final class Request {
      final HttpUrl url;
      final String method;
      final Headers headers;
      final RequestBody body;
      final Object tag;
    
      private volatile CacheControl cacheControl; // Lazily initialized.
    }

Request 对象主要封装的是一些网络请求的信息，比如请求 url，请求方法，请求头，请求 body 等，也比较简单，这里不再展开阐述。

### Call 对象 ###

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

可以看到 call 对象实际是 RealCall 的实例化对象

#### RealCall\#execute() ####

@Override public Response execute() throws IOException {
      synchronized (this) {
        if (executed) throw new IllegalStateException("Already Executed");
        executed = true;
      }
      captureCallStackTrace();
      try {
        // 执行 client.dispatcher() 的 executed 方法
        client.dispatcher().executed(this);
        Response result = getResponseWithInterceptorChain();
        if (result == null) throw new IOException("Canceled");
        return result;
      } finally {
        // 最后再执行 dispatcher 的 finish 方法
        client.dispatcher().finished(this);
      }
    }

在 execute 方法中，首先会调用 `client.dispatcher().executed(this)` 加入到 runningAsyncCalls 队列当中,接着执行 `getResponseWithInterceptorChain()` 获取请求结果，最终再执行 `client.dispatcher().finished(this)` 将 realCall 从 runningAsyncCalls 队列中移除 。

我们先来看一下 `getResponseWithInterceptorChain` 方法

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);
        return chain.proceed(originalRequest);
      }

可以看到，首先，他会将客户端的 interceptors 添加到 list 当中，接着，再添加 okhhttp 里面的 interceptor，然后构建了一个 `RealInterceptorChain` 对象，并将我们的 `List<Interceptor>` 作为成员变量，最后调用 RealInterceptorChain 的 proced 方法。

*  client.interceptors() -> 我们自己添加的请求拦截器，通常是做一些添加统一的token之类操作
 *  retryAndFollowUpInterceptor -> 主要负责错误重试和请求重定向
 *  BridgeInterceptor -> 负责添加网络请求相关的必要的一些请求头，比如Content-Type、Content-Length、Transfer-Encoding、User-Agent等等
 *  CacheInterceptor -> 负责处理缓存相关操作
 *  ConnectInterceptor -> 负责与服务器进行连接的操作
 *  networkInterceptors -> 同样是我们可以添加的拦截器的一种，它与client.interceptors() 不同的是二者拦截的位置不一样。
 *  CallServerInterceptor -> 在这个拦截器中才会进行真实的网络请求

Interceptor 里面是怎样实现的，这里我们暂不讨论，接下来，我们来看一下 proceed 方法

**proceed 方法**

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
          Connection connection) throws IOException {
         
         // 省略无关代码
        
    
        //  生成 list 当中下一个 interceptot 的 chain 对象
        RealInterceptorChain next = new RealInterceptorChain(
            interceptors, streamAllocation, httpCodec, connection, index + 1, request);
        // 当前的 interceptor
        Interceptor interceptor = interceptors.get(index);
        // 当前的 intercept 处理下一个 intercept 包装的 chain 对象
        Response response = interceptor.intercept(next);
    
        // ----
    
        return response;
      }

proceed 方法也很简单，proceed方法每次从拦截器列表中取出拦截器，并调用 interceptor.intercept(next)。

熟悉 Okhttp 的应该都在回到，我们在 addInterceptor 创建 Interceptor 实例，最终都会调用 `chain.proceed(Request request)`,从而形成一种链式调用。关于责任链模式的可以看我的这一篇文章 [责任链模式以及在 Android 中的应用][Android]

OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request.Builder builder = request.newBuilder().addHeader("name","test");
            return chain.proceed(builder.build());
        }
    }).build();

![format_png 1][]

而 OkHttp 是怎样结束循环调用的，这是因为最后一个拦截器 CallServerInterceptor 并没有调用chain.proceed(request)，所以能够结束循环调用。

### dispatcher ###

public final class Dispatcher {
      private int maxRequests = 64;
      private int maxRequestsPerHost = 5;
      private Runnable idleCallback;
    
      /** Executes calls. Created lazily. */
      private ExecutorService executorService;
    
      // 异步的请求等待队列
      private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
    
      // 异步的正在请求的队列
      private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
    
      // 绒布的正在请求的队列
      private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
      
    }

### 异步请求 enqueue(Callback responseCallback) ###

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

首先，我们先来看一下 AsyncCall 这个类

final class AsyncCall extends NamedRunnable {
      private final Callback responseCallback;
    
      // ----
    
      @Override protected void execute() {
        boolean signalledCallback = false;
        try {
          Response response = getResponseWithInterceptorChain();
          // 判断请求是否取消了，如果取消了，直接回调 onFailure
          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 {
            responseCallback.onFailure(RealCall.this, e);
          }
        } finally {
          client.dispatcher().finished(this);
        }
      }
    }

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 继承 NamedRunnable, 而 NamedRunnable 是 Runnable 的子类，当执行 run 方法时，会执行 execute 方法。

我们再来看一下 dispatcher 的 enqueue 方法

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

可以看到当正在请求的请求数小于 `maxRequests` 的时候并且当前正在请求的队列里面相当 host 的小于 `maxRequestsPerHost`, 直接添加到 `runningAsyncCalls` 队列中，并添加到线程池里面执行，否则添加到准备队列 `readyAsyncCalls` 里面。

当执行 `executorService().execute(call)` 的时候，会调用 run 方法， run 方法又会调用到 execute 方法进行网络请求，请求完成之后，会调用 `client.dispatcher().finished(this)` 从队列里面移除。

到此， Okhttp 的主要流程已经讲完

--------------------

### 小结 ###

1.  有一个分发器 Dispatcher，里面有三个请求队列，一个是正在请求的队列，一个是等待队列，另外一个是同步的正在请求的队列，当我们执行 enqueue 方法的时候，他会判断正在请求队列数量是否超过允许的最大并发数量（默认是 64）（线程池的原理），如果超过了，会添加到等待队列里面。  
    excute 方法是同步执行的，每次执行会添加到同步请求队列当中，执行完毕之后会移除
2.  设计的核心思想责任链模式，当我们需要拦截的时候，可以实现 Interceptor 接口，会按照添加的顺序执行 Chain.proceed 方法。
3.  职责分明，OkhttpClient 对象主要处理一些基础的配置，比如连接超时，读写超时，添加拦截器。Request 主要配置请求方法，请求头等。

### 推荐阅读 ###

[责任链模式以及在 Android 中的应用][Android]

[ 观察者设计模式 Vs 事件委托（java）][_ Vs _java]

[装饰者模式及其应用][Link 1]

[建造者模式（Builder）及其应用][Builder 1]

[二次封装图片第三方框架——简单工厂模式的运用][Link 2]

[Android 二次封装网络加载框架][Android 1]

[java 代理模式详解][java]

[Rxjava 2.x 源码系列 - 基础框架分析][Rxjava 2.x _ -]

[Rxjava 2.x 源码系列 - 线程切换 （上）][Rxjava 2.x _ - _]

[Rxjava 2.x 源码系列 - 线程切换 （下）][Rxjava 2.x _ - _ 1]

[Rxjava 2.x 源码系列 - 变换操作符 Map（上）][Rxjava 2.x _ - _ Map]

[butterknife 源码分析][butterknife]

[一步步拆解 LeakCanary][LeakCanary]

[java 源码系列 - 带你读懂 Reference 和 ReferenceQueue][java _ - _ Reference _ ReferenceQueue]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS85LzQvMTZjZmMwNDc1OWQzMmEzNQ?x-oss-process=image/format,png
[Builder]: https://xujun.blog.csdn.net/article/details/52124383
[Android]: https://blog.csdn.net/gdutxiaoxu/article/details/100189121
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS85LzQvMTZjZmMwNDc1YTgxNWFkYQ?x-oss-process=image/format,png
[_ Vs _java]: http://blog.csdn.net/gdutxiaoxu/article/details/51824769
[Link 1]: http://blog.csdn.net/gdutxiaoxu/article/details/51885105
[Builder 1]: https://blog.csdn.net/gdutxiaoxu/article/details/52124383
[Link 2]: https://blog.csdn.net/gdutxiaoxu/article/details/54564442
[Android 1]: https://blog.csdn.net/gdutxiaoxu/article/details/78577450
[java]: https://blog.csdn.net/gdutxiaoxu/article/details/81394050
[Rxjava 2.x _ -]: https://blog.csdn.net/gdutxiaoxu/article/details/80501816
[Rxjava 2.x _ - _]: https://blog.csdn.net/gdutxiaoxu/article/details/80577389
[Rxjava 2.x _ - _ 1]: https://blog.csdn.net/gdutxiaoxu/article/details/80599799
[Rxjava 2.x _ - _ Map]: https://blog.csdn.net/gdutxiaoxu/article/details/80684901
[butterknife]: https://blog.csdn.net/gdutxiaoxu/article/details/71512754
[LeakCanary]: https://blog.csdn.net/gdutxiaoxu/article/details/80752876
[java _ - _ Reference _ ReferenceQueue]: https://blog.csdn.net/gdutxiaoxu/article/details/80738581