前言

在面試中，OkHttp作為我們基本屬於必用的第三方庫來說，也是一個非常重要的考點，所以對其原理的掌握也會讓我們的能力得到一定的提升。

一般進OkHttp的官網是需要翻牆的。

基本使用

先一段引入關於OkHttp的使用，這是直接拉取了官網掛著的使用方法。 因為在一般的使用過程中，後臺可能會通過比較帶有的session或者cookie來判斷當前使用者是否和快取的使用者相同，所以一般一個專案整體使用單個OkHttpClient的物件。

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}
複製程式碼

TCP/IP模型

TCP/IP模型	協議	資料	網路裝置
應用層	HTTP(超文字傳輸)、FTP(檔案傳輸)、SMTP(簡單郵件傳輸)、Telnet(遠端登入)、DNS(域名)	訊息	協議轉化器
TCP層	TCP、UDP	報文段	協議轉化器
IP層	IP(網際協議)、ICMP(因特網控制報文協議)、ARP(地址解析協議)、DHCP(動態主機配置協議)、RIP、OSPF、BGP	資料包	路由器
資料鏈路層	PPP、HDLC、ARQ	幀	網橋、交換機
物理層		位元	中繼器、集線器(Hub)

因為OkHttp實現的基礎是對一個網路整體模型的一個理解，所以知道TCP/IP模型中的一些知識是必要的。

原始碼解析

OkHttpClient client = new OkHttpClient.Builder().build();
Request request = new Request.Builder()
                .url(url)
                .build();

Call call = client.newCall(request);
call.enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {

        }

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

        }
});
複製程式碼

這是我們的在okhttp中使用的方法，整個專案的解析將圍繞下面5個類進行。

• OkHttpClient
• Request
• Call
• Callback
• Response

首先是OkHttpClient和Request。 為什麼這兩個一起講解呢？因為兩個構造方式相同OkHttpClient是一個全域性掌控者，Request是一個請求體的封裝。

public final class Request {
  final HttpUrl url; // 路徑
  final String method; // 請求方式
  final Headers headers; // 請求頭
  final @Nullable RequestBody body; // 請求體
  final Object tag;
}

public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
  final Dispatcher dispatcher;
  final @Nullable Proxy proxy;
  final List<Protocol> protocols;
  final List<ConnectionSpec> connectionSpecs;
  final List<Interceptor> interceptors; // 攔截器
  final List<Interceptor> networkInterceptors; // 網路攔截器
  final EventListener.Factory eventListenerFactory;
  final ProxySelector proxySelector;
  final CookieJar cookieJar;
  final @Nullable Cache cache;
  final @Nullable InternalCache internalCache;
  final SocketFactory socketFactory;
  final @Nullable SSLSocketFactory sslSocketFactory;
  final @Nullable CertificateChainCleaner certificateChainCleaner;
  final HostnameVerifier hostnameVerifier;
  final CertificatePinner certificatePinner;
  final Authenticator proxyAuthenticator;
  final Authenticator authenticator;
  final ConnectionPool connectionPool;
  final Dns dns;
  final boolean followSslRedirects;
  final boolean followRedirects;
  final boolean retryOnConnectionFailure;
  final int connectTimeout;
  final int readTimeout;
  final int writeTimeout;
  final int pingInterval;
}
複製程式碼

能看到OkHttpClient的內部元素很多，但是我們很多時間並不會進行使用，是因為他自己已經做了很多層的封裝，另外他們這種建立物件的模式又稱為構建型設計模式。

接下來就是Call這個類，根據模版寫法，我們知道需要將封裝好的Request請求體資料塞入OkHttpClient中返回的就是一個Call。

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

通過進入newCall()方法，我們知道返回的資料其實是實現Call的介面一個具體類RealCall，具體操作我們不用知道，我們只用知道返回的一個具體類是什麼就可以了，因為往後的操作都是圍繞一個具體的東西展開的。 在看模版的下一句話call.enqueue(...)，進入函式，我們可以看到下述的函式。

@Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      // 是一個以private修飾的變數，呼叫一次這個函式就變為true
      // 說明一個call只能呼叫一次enqueue函式
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
複製程式碼

其他都還好，直接看到上述最後一行程式碼，因為我們需要將任務釋出出去，並且拿到資料。

  synchronized void enqueue(AsyncCall call) {
    // 正在執行的數量不能超過maxRequests=64
    // 向同一主機發出的請求不能超過maxRequestsPerHost=5
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call); // 1
    } else {
      readyAsyncCalls.add(call);
    }
  }
複製程式碼

註釋1處其實就是一個執行緒池，enqueue()的作用就是將整一個請求放入，並置為非同步，而使用的執行緒池型別就是CachedThreadPool。 但是我們雖然知道了這是一個非同步處理，但是我們並沒有看到我們要看的資料呀。。。。 所以我們只能暫時停下，思考一個問題了。執行緒池執行的是什麼？是執行緒啊！！！！！但是我們只看到了一個什麼東西，是一個AsyncCall的變數，這是啥，這隻可能是一個Runnable唄，還能是啥。。。當我們點進去之後，我們就能夠發現他的執行函式execute()。

 @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        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);
      }
    }
  }
複製程式碼

在這裡我們能夠驚奇的發現下述的幾段程式碼。

responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
responseCallback.onResponse(RealCall.this, response);
responseCallback.onFailure(RealCall.this, e);
複製程式碼

而他們對應就是我們的Callback了，但是很糟心的是他們非要改的樣貌出現。又有讀者問了，就算我們找到了，我們知道一般繼承自Runnable的都是重寫run()方法不是？？ 那我們只好繼續溯源這個AsyncCall類了，他繼承自一個NamedRunnable抽象類，我們進去看看好了。

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();
}
複製程式碼

程式碼也不長，就直接看全貌了，原來這是一個已經經過一步封裝的Runnable，那這裡基本已經揭曉了資料的來源了。

最後解釋一個response的來源了，我們已經看到了這樣一句話。

Response response = getResponseWithInterceptorChain();
// 通過點選可得下述的函式。
Response getResponseWithInterceptorChain() throws IOException {
    // 一堆的攔截器配置
    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);
  }
複製程式碼

其實他就是通過一堆的攔截器來獲取資料的，但是顯然這裡不是終點站，因為我們看到的return中就還是一個函式，說明答案還在這個函式中。通過觀察我們很容易得知，這個的操作的具體類是一個叫做RealInterceptorChain的類。

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    。。。。。
    // 一個很簡單的邏輯，就是通過遍歷攔截器，檢查誰拿得到
    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);

    。。。。
    return response;
  }
複製程式碼

如圖所示，哪個攔截器能攔截成功，就會返回我們需要的資料Response。

總結

接下來我們通過一張圖來完成對整個OkHttp的工作流程梳理。

以上就是我的學習成果，如果有什麼我沒有思考到的地方或是文章記憶體在錯誤，歡迎與我分享。

---

相關文章推薦：

手撕ButterKnife

手撕AsyncTask

知道Handler，那你知道HandlerThread嗎？

手撕Handler