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

Response response = client.newCall(request).execute();

    client.newCall(request).enqueue(new Callback() {
      @Override
      public void onFailure(@NotNull Call call, @NotNull IOException e) {
      //todo handle request failed
      }
      @Override
      public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
          //todo handle Response
      }
    });

open class OkHttpClient internal constructor(
  builder: Builder
) : Cloneable, Call.Factory, WebSocket.Factory {
  constructor() : this(Builder())
  class Builder constructor() {
    //調度器
    internal var dispatcher: Dispatcher = Dispatcher()
    //連接池
    internal var connectionPool: ConnectionPool = ConnectionPool()
    //整體流程攔截器
    internal val interceptors: MutableList<Interceptor> = mutableListOf()
    //網絡流程攔截器
    internal val networkInterceptors: MutableList<Interceptor> = mutableListOf()
    //流程監(jiān)聽器
    internal var eventListenerFactory: EventListener.Factory = EventListener.NONE.asFactory()
    //連接失敗時是否重連
    internal var retryOnConnectionFailure = true
    //服務器認證設置
    internal var authenticator: Authenticator = Authenticator.NONE
    //是否重定向
    internal var followRedirects = true
    //是否從HTTP重定向到HTTPS
    internal var followSslRedirects = true
    //cookie設置
    internal var cookieJar: CookieJar = CookieJar.NO_COOKIES
    //緩存設置
    internal var cache: Cache? = null
    //DNS設置
    internal var dns: Dns = Dns.SYSTEM
    //代理設置
    internal var proxy: Proxy? = null
    //代理選擇器設置
    internal var proxySelector: ProxySelector? = null
    //代理服務器認證設置
    internal var proxyAuthenticator: Authenticator = Authenticator.NONE
    //socket配置
    internal var socketFactory: SocketFactory = SocketFactory.getDefault()
    //https socket配置
    internal var sslSocketFactoryOrNull: SSLSocketFactory? = null
    internal var x509TrustManagerOrNull: X509TrustManager? = null
    internal var connectionSpecs: List<ConnectionSpec> = DEFAULT_CONNECTION_SPECS
    //協(xié)議
    internal var protocols: List<Protocol> = DEFAULT_PROTOCOLS
    //域名校驗
    internal var hostnameVerifier: HostnameVerifier = OkHostnameVerifier
    internal var certificatePinner: CertificatePinner = CertificatePinner.DEFAULT
    internal var certificateChainCleaner: CertificateChainCleaner? = null
    //請求超時
    internal var callTimeout = 0
    //連接超時
    internal var connectTimeout = 10_000
    //讀取超時
    internal var readTimeout = 10_000
    //寫入超時
    internal var writeTimeout = 10_000
    internal var pingInterval = 0
    internal var minWebSocketMessageToCompress = RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE
    internal var routeDatabase: RouteDatabase? = null
···省略代碼···

class Request internal constructor(
  @get:JvmName("url") val url: HttpUrl,
  @get:JvmName("method") val method: String,
  @get:JvmName("headers") val headers: Headers,
  @get:JvmName("body") val body: RequestBody?,
  internal val tags: Map<Class<*>, Any>
) {
  open class Builder {
    //請求的URL
    internal var url: HttpUrl? = null
    //請求方法，如：GET、POST..
    internal var method: String
    //請求頭
    internal var headers: Headers.Builder
    //請求體
    internal var body: RequestBody? = null
  ···省略代碼···

interface Call : Cloneable {
  /** 返回發(fā)起此調用的原始請求 */
  fun request(): Request
  /**
   * 同步請求，立即執(zhí)行。
   * 
   * 拋出兩種異常：
   * 1. 請求失敗拋出IOException;
   * 2. 如果在執(zhí)行過一回的前提下再次執(zhí)行拋出IllegalStateException；*/
  @Throws(IOException::class)
  fun execute(): Response
  /**
   * 異步請求，將請求安排在將來的某個時間點執(zhí)行。
   * 如果在執(zhí)行過一回的前提下再次執(zhí)行拋出IllegalStateException */
  fun enqueue(responseCallback: Callback)
  /** 取消請求。已經完成的請求不能被取消 */
  fun cancel()
  /** 是否已被執(zhí)行  */
  fun isExecuted(): Boolean
  /** 是否被取消   */
  fun isCanceled(): Boolean
  /** 一個完整Call請求流程的超時時間配置，默認選自[OkHttpClient.Builder.callTimeout] */
  fun timeout(): Timeout
  /** 克隆這個call，創(chuàng)建一個新的相同的Call */
  public override fun clone(): Call
  /** 利用工廠模式來讓 OkHttpClient 來創(chuàng)建 Call對象 */
  fun interface Factory {
    fun newCall(request: Request): Call
  }
}

OkHttpClient.kt
override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

inner class AsyncCall(
    //用戶傳入的響應回調方法
    private val responseCallback: Callback
  ) : Runnable {
    //同一個域名的請求次數(shù)，volatile + AtomicInteger 保證在多線程下及時可見性與原子性
    @Volatile var callsPerHost = AtomicInteger(0)
      private set
    fun reuseCallsPerHostFrom(other: AsyncCall) {
      this.callsPerHost = other.callsPerHost
    }
···省略代碼···
    fun executeOn(executorService: ExecutorService) {
      client.dispatcher.assertThreadDoesntHoldLock()
      var success = false
      try {
        //調用線程池執(zhí)行
        executorService.execute(this)
        success = true
      } catch (e: RejectedExecutionException) {
        val ioException = InterruptedIOException("executor rejected")
        ioException.initCause(e)
        noMoreExchanges(ioException)
        //請求失敗，調用 Callback.onFailure() 方法
        responseCallback.onFailure(this@RealCall, ioException)
      } finally {
        if (!success) {
          //請求失敗，調用調度器finish方法
          client.dispatcher.finished(this) // This call is no longer running!
        }
      }
    }
    override fun run() {
      threadName("OkHttp ${redactedUrl()}") {
        var signalledCallback = false
        timeout.enter()
        try {
          //請求成功，獲取到服務器返回的response
          val response = getResponseWithInterceptorChain()
          signalledCallback = true
          //調用 Callback.onResponse() 方法，將 response 傳遞出去
          responseCallback.onResponse(this@RealCall, response)
        } catch (e: IOException) {
          if (signalledCallback) {
            // Do not signal the callback twice!
            Platform.get().log("Callback failure for ${toLoggableString()}", Platform.INFO, e)
          } else {
            //請求失敗，調用 Callback.onFailure() 方法
            responseCallback.onFailure(this@RealCall, e)
          }
        } catch (t: Throwable) {
          //請求出現(xiàn)異常，調用cancel方法來取消請求
          cancel()
          if (!signalledCallback) {
            val canceledException = IOException("canceled due to $t")
            canceledException.addSuppressed(t)
            //請求失敗，調用 Callback.onFailure() 方法
            responseCallback.onFailure(this@RealCall, canceledException)
          }
          throw t
        } finally {
          //請求結束，調用調度器finish方法
          client.dispatcher.finished(this)
        }
      }
    }
  }

class Dispatcher constructor() {
  @get:Synchronized
  @get:JvmName("executorService") val executorService: ExecutorService
    get() {
      if (executorServiceOrNull == null) {
        //創(chuàng)建一個緩存線程池，來處理請求調用,這個線程池的核心線程數(shù)是0，等待隊列的長度也是0，意味著
        //線程池會直接創(chuàng)建新的線程去處理請求
        executorServiceOrNull = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS,
            SynchronousQueue(), threadFactory("$okHttpName Dispatcher", false))
      }
      return executorServiceOrNull!!
    }
  /** 已準備好的異步請求隊列 */
  @get:Synchronized
  private val readyAsyncCalls = ArrayDeque<AsyncCall>()
  /** 正在運行的異步請求隊列, 包含取消但是還未finish的AsyncCall */
  private val runningAsyncCalls = ArrayDeque<AsyncCall>()
  /** 正在運行的同步請求隊列, 包含取消但是還未finish的RealCall */
  private val runningSyncCalls = ArrayDeque<RealCall>()
···省略代碼···
}

client.newCall(request).execute();

  RealCall.kt
  override fun execute(): Response {
    //CAS判斷是否已經被執(zhí)行了, 確保只能執(zhí)行一次，如果已經執(zhí)行過，則拋出異常
    check(executed.compareAndSet(false, true)) { "Already Executed" }
    //請求超時開始計時
    timeout.enter()
    //開啟請求監(jiān)聽
    callStart()
    try {
      //調用調度器中的 executed() 方法，調度器只是將 call 加入到了runningSyncCalls隊列中
      client.dispatcher.executed(this)
      //調用getResponseWithInterceptorChain 方法拿到 response
      return getResponseWithInterceptorChain()
    } finally {
      //執(zhí)行完畢，調度器將該 call 從 runningSyncCalls隊列中移除
      client.dispatcher.finished(this)
    }
  }
  Dispatcher.kt
  @Synchronized internal fun executed(call: RealCall) {
    runningSyncCalls.add(call)
  }

  RealCall.kt
  override fun enqueue(responseCallback: Callback) {
    //CAS判斷是否已經被執(zhí)行了, 確保只能執(zhí)行一次，如果已經執(zhí)行過，則拋出異常
    check(executed.compareAndSet(false, true)) { "Already Executed" }
    //開啟請求監(jiān)聽
    callStart()
    //新建一個AsyncCall對象，通過調度器enqueue方法加入到readyAsyncCalls隊列中
    client.dispatcher.enqueue(AsyncCall(responseCallback))
  }

  Dispatcher.kt
  internal fun enqueue(call: AsyncCall) {
    //加鎖，保證線程安全
    synchronized(this) {
      //將該請求調用加入到 readyAsyncCalls 隊列中
      readyAsyncCalls.add(call)
      // Mutate the AsyncCall so that it shares the AtomicInteger of an existing running call to
      // the same host.
      if (!call.call.forWebSocket) {
        //通過域名來查找有沒有相同域名的請求，有則復用。
        val existingCall = findExistingCallWithHost(call.host)
        if (existingCall != null) call.reuseCallsPerHostFrom(existingCall)
      }
    }
    //執(zhí)行請求
    promoteAndExecute()
  }
  private fun promoteAndExecute(): Boolean {
    this.assertThreadDoesntHoldLock()
    val executableCalls = mutableListOf<AsyncCall>()
    //判斷是否有請求正在執(zhí)行
    val isRunning: Boolean
    //加鎖，保證線程安全
    synchronized(this) {
      //遍歷 readyAsyncCalls 隊列
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()
        //runningAsyncCalls 的數(shù)量不能大于最大并發(fā)請求數(shù) 64
        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.
        //同域名最大請求數(shù)5，同一個域名最多允許5條線程同時執(zhí)行請求
        if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // Host max capacity.
        //從 readyAsyncCalls 隊列中移除，并加入到 executableCalls 及 runningAsyncCalls 隊列中
        i.remove()
        asyncCall.callsPerHost.incrementAndGet()
        executableCalls.add(asyncCall)
        runningAsyncCalls.add(asyncCall)
      }
      //通過運行隊列中的請求數(shù)量來判斷是否有請求正在執(zhí)行
      isRunning = runningCallsCount() > 0
    }
    //遍歷可執(zhí)行隊列，調用線程池來執(zhí)行AsyncCall
    for (i in 0 until executableCalls.size) {
      val asyncCall = executableCalls[i]
      asyncCall.executeOn(executorService)
    }
    return isRunning
  }

  Dispatcher.kt
  /** 異步請求調用結束方法 */
  internal fun finished(call: AsyncCall) {
    call.callsPerHost.decrementAndGet()
    finished(runningAsyncCalls, call)
  }
  /** 同步請求調用結束方法 */
  internal fun finished(call: RealCall) {
    finished(runningSyncCalls, call)
  }
  private fun <T> finished(calls: Deque<T>, call: T) {
    val idleCallback: Runnable?
    synchronized(this) {
      //將當前請求調用從 正在運行隊列 中移除
      if (!calls.remove(call)) throw AssertionError("Call wasn't in-flight!")
      idleCallback = this.idleCallback
    }
    //繼續(xù)執(zhí)行剩余請求，將call從readyAsyncCalls中取出加入到runningAsyncCalls，然后執(zhí)行
    val isRunning = promoteAndExecute()
    if (!isRunning && idleCallback != null) {
      //如果執(zhí)行完了所有請求，處于閑置狀態(tài)，調用閑置回調方法
      idleCallback.run()
    }
  }

  internal fun getResponseWithInterceptorChain(): Response {
    //攔截器列表
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor(client)
    interceptors += BridgeInterceptor(client.cookieJar)
    interceptors += CacheInterceptor(client.cache)
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }
    interceptors += CallServerInterceptor(forWebSocket)
    //構建攔截器責任鏈
    val chain = RealInterceptorChain(
        call = this,
        interceptors = interceptors,
        index = 0,
        exchange = null,
        request = originalRequest,
        connectTimeoutMillis = client.connectTimeoutMillis,
        readTimeoutMillis = client.readTimeoutMillis,
        writeTimeoutMillis = client.writeTimeoutMillis
    )
    //如果call請求完成，那就意味著交互完成了，沒有更多的東西來交換了
    var calledNoMoreExchanges = false
    try {
      //執(zhí)行攔截器責任鏈來獲取 response
      val response = chain.proceed(originalRequest)
      //如果被取消，關閉響應，拋出異常
      if (isCanceled()) {
        response.closeQuietly()
        throw IOException("Canceled")
      }
      return response
    } catch (e: IOException) {
      calledNoMoreExchanges = true
      throw noMoreExchanges(e) as Throwable
    } finally {
      if (!calledNoMoreExchanges) {
        noMoreExchanges(null)
      }
    }
  }

fun interface Interceptor {
  /** 攔截方法 */
  @Throws(IOException::class)
  fun intercept(chain: Chain): Response
  interface Chain {
    /** 原始請求數(shù)據 */
    fun request(): Request
    /** 核心方法，處理請求，獲取response */
    @Throws(IOException::class)
    fun proceed(request: Request): Response
    fun connection(): Connection?
    fun call(): Call
    fun connectTimeoutMillis(): Int
    fun withConnectTimeout(timeout: Int, unit: TimeUnit): Chain
    fun readTimeoutMillis(): Int
    fun withReadTimeout(timeout: Int, unit: TimeUnit): Chain
    fun writeTimeoutMillis(): Int
    fun withWriteTimeout(timeout: Int, unit: TimeUnit): Chain
  }
}

class RealInterceptorChain(
  internal val call: RealCall,
  private val interceptors: List<Interceptor>,
  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int
) : Interceptor.Chain {
···省略代碼···
  private var calls: Int = 0
  override fun call(): Call = call
  override fun request(): Request = request
  @Throws(IOException::class)
  override fun proceed(request: Request): Response {
    check(index < interceptors.size)
    calls++
    if (exchange != null) {
      check(exchange.finder.sameHostAndPort(request.url)) {
        "network interceptor ${interceptors[index - 1]} must retain the same host and port"
      }
      check(calls == 1) {
        "network interceptor ${interceptors[index - 1]} must call proceed() exactly once"
      }
    }
    //index+1, 復制創(chuàng)建新的責任鏈，也就意味著調用責任鏈中的下一個處理者，也就是下一個攔截器
    val next = copy(index = index + 1, request = request)
    //取出當前攔截器
    val interceptor = interceptors[index]
    //執(zhí)行當前攔截器的攔截方法
    @Suppress("USELESS_ELVIS")
    val response = interceptor.intercept(next) ?: throw NullPointerException(
        "interceptor $interceptor returned null")
    if (exchange != null) {
      check(index + 1 >= interceptors.size || next.calls == 1) {
        "network interceptor $interceptor must call proceed() exactly once"
      }
    }
    check(response.body != null) { "interceptor $interceptor returned a response with no body" }
    return response
  }
}

class HeaderInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request().newBuilder()
                .addHeader("device-android", "xxxxxxxxxxx")
                .addHeader("country-code", "ZH")
                .build();
        return chain.proceed(request);
    }
}
//然后在 OkHttpClient 中加入
OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(60, TimeUnit.SECONDS)
    .readTimeout(15, TimeUnit.SECONDS)
    .writeTimeout(15, TimeUnit.SECONDS)
    .cookieJar(new MyCookieJar())
    .addInterceptor(new HeaderInterceptor())//添加自定義Header攔截器
    .build();

class RetryAndFollowUpInterceptor(private val client: OkHttpClient) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    var request = chain.request
    val call = realChain.call
    var followUpCount = 0
    var priorResponse: Response? = null
    var newExchangeFinder = true
    var recoveredFailures = listOf<IOException>()
    while (true) {
      //這里會新建一個ExchangeFinder，ConnectInterceptor會使用到
      call.enterNetworkInterceptorExchange(request, newExchangeFinder)
      var response: Response
      var closeActiveExchange = true
      try {
        if (call.isCanceled()) {
          throw IOException("Canceled")
        }
        try {
          response = realChain.proceed(request)
          newExchangeFinder = true
        } catch (e: RouteException) {
          //嘗試通過路由連接失敗。該請求將不會被發(fā)送。
          if (!recover(e.lastConnectException, call, request, requestSendStarted = false)) {
            throw e.firstConnectException.withSuppressed(recoveredFailures)
          } else {
            recoveredFailures += e.firstConnectException
          }
          newExchangeFinder = false
          continue
        } catch (e: IOException) {
          //嘗試與服務器通信失敗。該請求可能已發(fā)送。
          if (!recover(e, call, request, requestSendStarted = e !is ConnectionShutdownException)) {
            throw e.withSuppressed(recoveredFailures)
          } else {
            recoveredFailures += e
          }
          newExchangeFinder = false
          continue
        }
        // Attach the prior response if it exists. Such responses never have a body.
        //嘗試關聯(lián)上一個response，注意：body是為null
        if (priorResponse != null) {
          response = response.newBuilder()
              .priorResponse(priorResponse.newBuilder()
                  .body(null)
                  .build())
              .build()
        }
        val exchange = call.interceptorScopedExchange
        //會根據 responseCode 來判斷，構建一個新的request并返回來重試或者重定向
        val followUp = followUpRequest(response, exchange)
        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false
          return response
        }
        //如果請求體是一次性的，不需要再次重試
        val followUpBody = followUp.body
        if (followUpBody != null && followUpBody.isOneShot()) {
          closeActiveExchange = false
          return response
        }
        response.body?.closeQuietly()
        //最大重試次數(shù)，不同的瀏覽器是不同的，比如：Chrome為21，Safari則是16
        if (++followUpCount > MAX_FOLLOW_UPS) {
          throw ProtocolException("Too many follow-up requests: $followUpCount")
        }
        request = followUp
        priorResponse = response
      } finally {
        call.exitNetworkInterceptorExchange(closeActiveExchange)
      }
    }
  }
  /** 判斷是否要進行重連，false->不嘗試重連；true->嘗試重連。*/
  private fun recover(
    e: IOException,
    call: RealCall,
    userRequest: Request,
    requestSendStarted: Boolean
  ): Boolean {
    //客戶端禁止重試
    if (!client.retryOnConnectionFailure) return false
    //不能再次發(fā)送該請求體
    if (requestSendStarted && requestIsOneShot(e, userRequest)) return false
    //發(fā)生的異常是致命的，無法恢復，如:ProtocolException
    if (!isRecoverable(e, requestSendStarted)) return false
    //沒有更多的路由來嘗試重連
    if (!call.retryAfterFailure()) return false
    // 對于失敗恢復，使用帶有新連接的相同路由選擇器
    return true
  }
···省略代碼··· 

class BridgeInterceptor(private val cookieJar: CookieJar) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    //獲取原始請求數(shù)據
    val userRequest = chain.request()
    val requestBuilder = userRequest.newBuilder()
    //重新構建請求頭，請求體信息
    val body = userRequest.body
    val contentType = body.contentType()
    requestBuilder.header("Content-Type", contentType.toString())
    requestBuilder.header("Content-Length", contentLength.toString())
    requestBuilder.header("Transfer-Encoding", "chunked")
    requestBuilder.header("Host", userRequest.url.toHostHeader())
    requestBuilder.header("Connection", "Keep-Alive")
   ···省略代碼···
    //添加cookie
    val cookies = cookieJar.loadForRequest(userRequest.url)
    if (cookies.isNotEmpty()) {
      requestBuilder.header("Cookie", cookieHeader(cookies))
    }
    //添加user-agent
    if (userRequest.header("User-Agent") == null) {
      requestBuilder.header("User-Agent", userAgent)
    }
    //重新構建一個Request，然后執(zhí)行下一個攔截器來處理該請求
    val networkResponse = chain.proceed(requestBuilder.build())
    cookieJar.receiveHeaders(userRequest.url, networkResponse.headers)
    //創(chuàng)建一個新的responseBuilder，目的是將原始請求數(shù)據構建到response中
    val responseBuilder = networkResponse.newBuilder()
        .request(userRequest)
    if (transparentGzip &&
        "gzip".equals(networkResponse.header("Content-Encoding"), ignoreCase = true) &&
        networkResponse.promisesBody()) {
      val responseBody = networkResponse.body
      if (responseBody != null) {
        val gzipSource = GzipSource(responseBody.source())
        val strippedHeaders = networkResponse.headers.newBuilder()
            .removeAll("Content-Encoding")
            .removeAll("Content-Length")
            .build()
        //修改response header信息，移除Content-Encoding，Content-Length信息
        responseBuilder.headers(strippedHeaders)
        val contentType = networkResponse.header("Content-Type")
        //修改response body信息
        responseBuilder.body(RealResponseBody(contentType, -1L, gzipSource.buffer()))
      }
    }
    return responseBuilder.build()
···省略代碼···

class CacheInterceptor(internal val cache: Cache?) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val call = chain.call()
    //通過request從OkHttpClient.cache中獲取緩存
    val cacheCandidate = cache?.get(chain.request())
    val now = System.currentTimeMillis()
    //創(chuàng)建一個緩存策略，用來確定怎么使用緩存
    val strategy = CacheStrategy.Factory(now, chain.request(), cacheCandidate).compute()
    //為空表示不使用網絡，反之，則表示使用網絡
    val networkRequest = strategy.networkRequest
    //為空表示不使用緩存，反之，則表示使用緩存
    val cacheResponse = strategy.cacheResponse
    //追蹤網絡與緩存的使用情況
    cache?.trackResponse(strategy)
    val listener = (call as? RealCall)?.eventListener ?: EventListener.NONE
    //有緩存但不適用，關閉它
    if (cacheCandidate != null && cacheResponse == null) {
      cacheCandidate.body?.closeQuietly()
    }
    //如果網絡被禁止，但是緩存又是空的，構建一個code為504的response，并返回
    if (networkRequest == null && cacheResponse == null) {
      return Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(HTTP_GATEWAY_TIMEOUT)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build().also {
            listener.satisfactionFailure(call, it)
          }
    }
    //如果我們禁用了網絡不使用網絡，且有緩存，直接根據緩存內容構建并返回response
    if (networkRequest == null) {
      return cacheResponse!!.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build().also {
            listener.cacheHit(call, it)
          }
    }
    //為緩存添加監(jiān)聽
    if (cacheResponse != null) {
      listener.cacheConditionalHit(call, cacheResponse)
    } else if (cache != null) {
      listener.cacheMiss(call)
    }
    var networkResponse: Response? = null
    try {
      //責任鏈往下處理，從服務器返回response 賦值給 networkResponse
      networkResponse = chain.proceed(networkRequest)
    } finally {
      //捕獲I/O或其他異常，請求失敗，networkResponse為空，且有緩存的時候，不暴露緩存內容。
      if (networkResponse == null && cacheCandidate != null) {
        cacheCandidate.body?.closeQuietly()
      }
    }
    //如果有緩存
    if (cacheResponse != null) {
      //且網絡返回response code為304的時候，使用緩存內容新構建一個Response返回。
      if (networkResponse?.code == HTTP_NOT_MODIFIED) {
        val response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers, networkResponse.headers))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis)
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis)
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build()
        networkResponse.body!!.close()
        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        cache!!.trackConditionalCacheHit()
        cache.update(cacheResponse, response)
        return response.also {
          listener.cacheHit(call, it)
        }
      } else {
        //否則關閉緩存響應體
        cacheResponse.body?.closeQuietly()
      }
    }
    //構建網絡請求的response
    val response = networkResponse!!.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build()
    //如果cache不為null，即用戶在OkHttpClient中配置了緩存，則將上一步新構建的網絡請求response存到cache中
    if (cache != null) {
      //根據response的code,header以及CacheControl.noStore來判斷是否可以緩存
      if (response.promisesBody() && CacheStrategy.isCacheable(response, networkRequest)) {
        // 將該response存入緩存
        val cacheRequest = cache.put(response)
        return cacheWritingResponse(cacheRequest, response).also {
          if (cacheResponse != null) {
            listener.cacheMiss(call)
          }
        }
      }
      //根據請求方法來判斷緩存是否有效，只對Get請求進行緩存，其它方法的請求則移除
      if (HttpMethod.invalidatesCache(networkRequest.method)) {
        try {
          //緩存無效，將該請求緩存從client緩存配置中移除
          cache.remove(networkRequest)
        } catch (_: IOException) {
          // The cache cannot be written.
        }
      }
    }
    return response
  }
···省略代碼···  

object ConnectInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    //初始化一個exchange對象
    val exchange = realChain.call.initExchange(chain)
    //根據這個exchange對象來復制創(chuàng)建一個新的連接責任鏈
    val connectedChain = realChain.copy(exchange = exchange)
    //執(zhí)行該連接責任鏈
    return connectedChain.proceed(realChain.request)
  }
}

RealCall.kt
internal fun initExchange(chain: RealInterceptorChain): Exchange {
    ...省略代碼...
    //這里的exchangeFinder就是在RetryAndFollowUpInterceptor中創(chuàng)建的
    val exchangeFinder = this.exchangeFinder!!
    //返回一個ExchangeCodec（是個編碼器，為request編碼以及為response解碼）
    val codec = exchangeFinder.find(client, chain)
    //根據exchangeFinder與codec新構建一個Exchange對象，并返回
    val result = Exchange(this, eventListener, exchangeFinder, codec)
  ...省略代碼...
    return result
  }

ExchangeFinder.kt
fun find(
    client: OkHttpClient,
    chain: RealInterceptorChain
  ): ExchangeCodec {
    try {
      //查找合格可用的連接，返回一個 RealConnection 對象
      val resultConnection = findHealthyConnection(
          connectTimeout = chain.connectTimeoutMillis,
          readTimeout = chain.readTimeoutMillis,
          writeTimeout = chain.writeTimeoutMillis,
          pingIntervalMillis = client.pingIntervalMillis,
          connectionRetryEnabled = client.retryOnConnectionFailure,
          doExtensiveHealthChecks = chain.request.method != "GET"
      )
      //根據連接，創(chuàng)建并返回一個請求響應編碼器：Http1ExchangeCodec 或者 Http2ExchangeCodec，分別對應Http1協(xié)議與Http2協(xié)議
      return resultConnection.newCodec(client, chain)
    } catch (e: RouteException) {
      trackFailure(e.lastConnectException)
      throw e
    } catch (e: IOException) {
      trackFailure(e)
      throw RouteException(e)
    }
  }

ExchangeFinder.kt
  private fun findHealthyConnection(
    connectTimeout: Int,
    readTimeout: Int,
    writeTimeout: Int,
    pingIntervalMillis: Int,
    connectionRetryEnabled: Boolean,
    doExtensiveHealthChecks: Boolean
  ): RealConnection {
    while (true) {
      //重點：查找連接
      val candidate = findConnection(
          connectTimeout = connectTimeout,
          readTimeout = readTimeout,
          writeTimeout = writeTimeout,
          pingIntervalMillis = pingIntervalMillis,
          connectionRetryEnabled = connectionRetryEnabled
      )
      //檢查該連接是否合格可用，合格則直接返回該連接
      if (candidate.isHealthy(doExtensiveHealthChecks)) {
        return candidate
      }
      //如果該連接不合格，標記為不可用，從連接池中移除
      candidate.noNewExchanges()
    ...省略代碼...
    }
  }

private fun findConnection(
    connectTimeout: Int, 
    readTimeout: Int,
    writeTimeout: Int,
    pingIntervalMillis: Int,
    connectionRetryEnabled: Boolean
  ): RealConnection {
    if (call.isCanceled()) throw IOException("Canceled")
    //第一次，嘗試重連 call 中的 connection，不需要去重新獲取連接
    val callConnection = call.connection // This may be mutated by releaseConnectionNoEvents()!
    if (callConnection != null) {
      var toClose: Socket? = null
      synchronized(callConnection) {
        if (callConnection.noNewExchanges || !sameHostAndPort(callConnection.route().address.url)) {
          toClose = call.releaseConnectionNoEvents()
        }
      }
      //如果 call 中的 connection 還沒有釋放，就重用它。
      if (call.connection != null) {
        check(toClose == null)
        return callConnection
      }
      //如果 call 中的 connection 已經被釋放，關閉Socket.
      toClose?.closeQuietly()
      eventListener.connectionReleased(call, callConnection)
    }
    //需要一個新的連接，所以重置一些狀態(tài)
    refusedStreamCount = 0
    connectionShutdownCount = 0
    otherFailureCount = 0
    //第二次，嘗試從連接池中獲取一個連接，不帶路由，不帶多路復用
    if (connectionPool.callAcquirePooledConnection(address, call, null, false)) {
      val result = call.connection!!
      eventListener.connectionAcquired(call, result)
      return result
    }
    //連接池中是空的，準備下次嘗試連接的路由
    val routes: List<Route>?
    val route: Route
    ...省略代碼...
      //第三次，再次嘗試從連接池中獲取一個連接，帶路由，不帶多路復用
      if (connectionPool.callAcquirePooledConnection(address, call, routes, false)) {
        val result = call.connection!!
        eventListener.connectionAcquired(call, result)
        return result
      }
      route = localRouteSelection.next()
    }
    //第四次，手動創(chuàng)建一個新連接
    val newConnection = RealConnection(connectionPool, route)
    call.connectionToCancel = newConnection
    try {
      newConnection.connect(
          connectTimeout,
          readTimeout,
          writeTimeout,
          pingIntervalMillis,
          connectionRetryEnabled,
          call,
          eventListener
      )
    } finally {
      call.connectionToCancel = null
    }
    call.client.routeDatabase.connected(newConnection.route())
    //第五次，再次嘗試從連接池中獲取一個連接，帶路由，帶多路復用。
    //這一步主要是為了校驗一下，比如已經有了一條連接了，就可以直接復用，而不用使用手動創(chuàng)建的新連接。
    if (connectionPool.callAcquirePooledConnection(address, call, routes, true)) {
      val result = call.connection!!
      nextRouteToTry = route
      newConnection.socket().closeQuietly()
      eventListener.connectionAcquired(call, result)
      return result
    }
    synchronized(newConnection) {
      //將手動創(chuàng)建的新連接放入連接池
      connectionPool.put(newConnection)
      call.acquireConnectionNoEvents(newConnection)
    }
    eventListener.connectionAcquired(call, newConnection)
    return newConnection
  }

class CallServerInterceptor(private val forWebSocket: Boolean) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.exchange!!
    val request = realChain.request
    val requestBody = request.body
    var invokeStartEvent = true
    var responseBuilder: Response.Builder? = null
    try {
      //寫入請求頭
      exchange.writeRequestHeaders(request)
      //如果不是GET請求，并且請求體不為空
      if (HttpMethod.permitsRequestBody(request.method) && requestBody != null) {
        //當請求頭為"Expect: 100-continue"時，在發(fā)送請求體之前需要等待服務器返回"HTTP/1.1 100 Continue" 的response，如果沒有等到該response，就不發(fā)送請求體。
        //POST請求，先發(fā)送請求頭，在獲取到100繼續(xù)狀態(tài)后繼續(xù)發(fā)送請求體
        if ("100-continue".equals(request.header("Expect"), ignoreCase = true)) {
          //刷新請求，即發(fā)送請求頭
          exchange.flushRequest()
          //解析響應頭
          responseBuilder = exchange.readResponseHeaders(expectContinue = true)
          exchange.responseHeadersStart()
          invokeStartEvent = false
        }
        //寫入請求體
        if (responseBuilder == null) {
          if (requestBody.isDuplex()) {
            //如果請求體是雙公體，就先發(fā)送請求頭，稍后在發(fā)送請求體
            exchange.flushRequest()
            val bufferedRequestBody = exchange.createRequestBody(request, true).buffer()
            //寫入請求體
            requestBody.writeTo(bufferedRequestBody)
          } else {
            //如果獲取到了"Expect: 100-continue"響應，寫入請求體
            val bufferedRequestBody = exchange.createRequestBody(request, false).buffer()
            requestBody.writeTo(bufferedRequestBody)
            bufferedRequestBody.close()
          }
       ···省略代碼···
        //請求結束，發(fā)送請求體
        exchange.finishRequest()
    ···省略代碼···
    try {
      if (responseBuilder == null) {
        //讀取響應頭
        responseBuilder = exchange.readResponseHeaders(expectContinue = false)!!
        ···省略代碼···
      //構建一個response
      var response = responseBuilder
          .request(request)
          .handshake(exchange.connection.handshake())
          .sentRequestAtMillis(sentRequestMillis)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build()
      var code = response.code
      ···省略代碼···
      return response
···省略代碼···