前言

說句廢話，作為一個工作幾年的程式設計師，在日常工作中，難免會用一些三方封裝庫，來方便我們的開發，但是不能僅僅會用就滿足，我們還了解它的工作原理。

正文

轉入正題，看到本文的朋友應該知道了OK給出的API的基本呼叫（本文不對基本使用做介紹，有需要自行看https://github.com/square/okhttp/wiki/Recipes），
那下面試著揭開OK的面紗，檢視內部是如何實現的。
準備工作： 首先去下載https://github.com/square/okhttp原始碼，然後maven編譯完成後匯入IDEA中。

在分析工作流程前，需要先了解幾個類：OkHttpClient，Call,Request,Response。

OkHttpClient： Call的工廠，可以傳送HTTP請求和讀取響應，推薦多個請求共享同一個client，每一個 client都持有自己的connection pool（連線池）和（執行緒池），reuse 連線和執行緒，減少了延遲和節省了記憶體的開支；相反，對每一個Request建立一個client浪費空閒池中的資源。

推薦建立singleton HTTP client的方式
使用：
public final OkHttpClient client = new OkHttpClient();
或者：
public final OkHttpClient client = new OkHttpClient.Builder()
   .addInterceptor(new
 
 HttpLoggingInterceptor())
   .cache(new Cache(cacheDir, cacheSize))
   .build();

執行緒和連線在空閒時會自動釋放。
關閉 dispatcher's executor service ，This will also cause future calls to the client to be rejected
client.dispatcher().executorService().shutdown()： 主動釋放後，以後的Call 呼叫也會被拒絕。

Clear the connection pool with
 
 client.connectionPool().evictAll() Note that the
清除連線池的操作：client.connectionPool().evictAll()，connection pool's daemon thread may not exit immediately.
連線池的守護執行緒可能不會立即退出。

關閉客戶端快取的方法

如果client 有cache，呼叫client.cache().close()，注：建立Calls 使用cache,但是設定了關閉cache會導致報錯？
If your client has a cache, call {@link Cache#close close()}. Note that it is an error to
create calls against a cache that is closed, and doing so will cause the call to crash.


Call ：A call is a request that has been prepared for execution. 準備被執行的請求，可以取消，一個call例項表示一個請求/響應對(流)，只能執行一次。

Request：An HTTP request.

Response：An HTTP response 這個類的例項不是不可變的，ResponseBody(響應體)是一個一次性的值，只被使用一次，然後被關閉。所有其他屬性都是不可變的。

接下來，就拿下面這個Get請求為例，看下Ok的內部工作流程吧。

package okhttp3.guide;

import java.io.IOException;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class GetExample {
  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();
    }
  }

  public static void main(String[] args) throws IOException {
    GetExample example = new GetExample();
    String response = example.run("https://raw.github.com/square/okhttp/master/README.md");
    System.out.println(response);
  }
}

第一步OkHttpClient初始化

首先對OkHttpClient初始化操作，發起Request前進行預設初始化設定，相當於準備工作。
下面是OkHttpClient 類中的部分屬性。

  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;

第二步 構建Request

接下來構建Request，指定是設定Request的 url ，請求型別 such as get/post …
以及request headers or request body , tag 。

下面是Request類中定義的部分屬性。

/**
 * An HTTP request. Instances of this class are immutable if their {@link #body} is null or itself
 * immutable.
 */
public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final @Nullable RequestBody body;
  final Object tag;
  private volatile CacheControl cacheControl; // Lazily initialized.

第三步發起Request返回Response

下面是發起請求的程式碼，我們拆開來看

try (Response response = client.newCall(request).execute()) {
      return response.body().string();
    }

client.newCall(request) 執行完後返回了Call 物件。

  /**
   * Prepares the {@code request} to be executed at some point in the future.
   */
  @Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
  }

我們可以看出RealCall.newRealCall(),返回了Call物件，看下RealCall

final class RealCall implements Call {
    /**省略部分程式碼*/
  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;
  }

 @Override public Response execute() throws IOException {
   /**省略部分程式碼*/
    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);
    }
    /**省略部分程式碼*/
  }

可以看出RealCall 實現了 Call介面，靜態方法newRealCall初始化一個RealCall物件，並且有一個execute()方法，這個方法返回值就是Response 物件，也就是說，我們呼叫client.newCall(request).execute()發起Request，然後返回 Response。

 Response response = getResponseWithInterceptorChain();

RealCall的execute()方法中有這樣一行程式碼，很顯然，是getResponseWithInterceptorChain()拿到了對應的Response 資訊，一起看下RealCall中的這個方法

  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, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());
    return chain.proceed(originalRequest);
  }

getResponseWithInterceptorChain方法首先把所有的interceptors封裝到一個集合中，然後把這個集合作為引數，初始化RealInterceptorChain【RealInterceptorChain是攔截器鏈，承載所有的攔截器鏈，包含：所有的自定義攔截器，OK核心，所有的網路攔截器，及網路呼叫。】
最後執行proceed(),現在我們一步步靠近Ok請求的核心了，看下proceed方法

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    /**省略部分程式碼*/
    // 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);
    /**省略部分程式碼*/
    return response;
  }

可以看到 chain內部的proceed方法最終還是執行的interceptor.intercept()方法拿到了Response,那幾回過頭看下前面getResponseWithInterceptorChain()方法中都有那些interceptor

 //只看interceptor
  Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    //client我們自己設定的interceptor
    interceptors.addAll(client.interceptors());
    //retryAndFollowUpInterceptor：請求失敗時，重試和重定向攔截器。
    interceptors.add(retryAndFollowUpInterceptor);
    //從應用程式程式碼到網路程式碼的橋樑
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //快取攔截器 從cache中讀取response和寫response到 cache
    interceptors.add(new CacheInterceptor(client.internalCache()));
    //開啟到目標伺服器的連線，並繼續執行下一個攔截器
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    //攔截器鏈中最後一個interceptor，It makes a network call to the server
    interceptors.add(new CallServerInterceptor(forWebSocket));
    /**省略部分程式碼*/
  }

註釋很明顯，最後一個CallServerInterceptor攔截器的任務是向Remote Server發起Request。又前面我們知道 呼叫的都是Interceptor的 intercept()方法，那最終，我們跟蹤一個發起的Request到了 CallServerInterceptor的intercept方法中。

@Override public Response intercept(Chain chain) throws IOException {
    /**
     * * A concrete interceptor chain that carries the entire interceptor chain: all application
     * interceptors, the OkHttp core, all network interceptors, and finally the network caller.
     * 攔截器 鏈 ，ok的核心，攔截器是網咯的呼叫者
     */
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    /**
     * Encodes HTTP requests and decodes HTTP responses. 編碼http請求，解碼http響應
     */
    HttpCodec httpCodec = realChain.httpStream();
    /**
     * 協調 Connections 、Stream、 Calls 之間關係的類。
     * Connections： physical socket connections to remote servers  ：物理Socket 連線遠端伺服器
     * Streams：HTTP request/response pairs  HTTP 請求/響應對。
     * Calls：a logical sequence of streams, typically an initial request and its follow up requests.
     *  一系列的流，通常是初始請求及後續請求，推薦每個call上面所有的流，使用相同的連結。
     * We prefer to keep all streams of a single call on the same connection for better behavior and locality.
     */
    StreamAllocation streamAllocation = realChain.streamAllocation();
    /**
     *  HTTP套接字和流  傳送和接收資料
     */
    RealConnection connection = (RealConnection) realChain.connection();
    /**
     * HTTP請求
     */
    Request request = realChain.request();

    long sentRequestMillis = System.currentTimeMillis();
    /**
     * 開始處理請求頭
     */
    realChain.eventListener().requestHeadersStart(realChain.call());
    httpCodec.writeRequestHeaders(request);
    realChain.eventListener().requestHeadersEnd(realChain.call(), request);

    Response.Builder responseBuilder = null;
    /**
     * 判斷請求方法 和請求body 不為空
     */
    if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
      // If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100
      // Continue" response before transmitting the request body. If we don't get that, return
      // what we did get (such as a 4xx response) without ever transmitting the request body.

      if (responseBuilder == null) {
        /**
         * Write the request body if the "Expect: 100-continue" expectation was met.
         * 如果“期望:100繼續”的期望得到滿足，請編寫請求體。
         */
        realChain.eventListener().requestBodyStart(realChain.call());
        long contentLength = request.body().contentLength();
        CountingSink requestBodyOut =
            new CountingSink(httpCodec.createRequestBody(request, contentLength));
        BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);

        request.body().writeTo(bufferedRequestBody);
        bufferedRequestBody.close();
        realChain.eventListener()
            .requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);
      } else if (!connection.isMultiplexed()) {
        // If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
        // from being reused. Otherwise we're still obligated to transmit the request body to
        // leave the connection in a consistent state.
        streamAllocation.noNewStreams();
      }
    }
    httpCodec.finishRequest();

    if (responseBuilder == null) {
      realChain.eventListener().responseHeadersStart(realChain.call());
      responseBuilder = httpCodec.readResponseHeaders(false);
    }
    /**
     * 初始化response物件
     */
    Response response = responseBuilder
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();
    /**
     * 響應頭
     */
    realChain.eventListener()
        .responseHeadersEnd(realChain.call(), response);

    int code = response.code();

    if (forWebSocket && code == 101) {
      /**
       *Connection is upgrading, but we need to ensure interceptors see a non-null response body.
       連線正在升級，但是我們需要確保攔截器看到一個非空響應體
        */
      response = response.newBuilder()
          .body(Util.EMPTY_RESPONSE)
          .build();
    } else {
      /**
       * 最終執行到這裡將response物件，構建完成，然後返回
       * 構建response 的ResponseBody
       */
      response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();

    }
    //===========刪除部分程式碼========================

    return response;
  }

這個方法比較重要，所以要看仔細一點，由此，我們可以得到我們想要的結果了。

結論

一個Request的發起到接收Response 經歷的過程：
首先構建OkHttpClient 物件，接下來使用構建好的Request作為引數傳遞給OkHttpClient 的newCall() 生成RealCall 物件，然後執行call的execute方法，最終這個方法內部通過CallServerInterceptor返回了Response，Response 封裝了伺服器返回的資料。

大體流程就是這樣，更多細節與流程圖稍後補充。