一步步帶你讀懂 Okhttp 源碼

  • 2019 年 10 月 25 日
  • 筆記

版權聲明：本文為部落客原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接和本聲明。

本文鏈接：https://blog.csdn.net/gdutxiaoxu/article/details/100545600

前言

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 的細節。

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 中的應用

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

而 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 主要配置請求方法，請求頭等。

VirMach 便宜 VPS

QNews

QNews