val request = Request.Builder()
    .url("")
    .addHeader("","")
    .get()
    .build()

  val okHttpClient = OkHttpClient.Builder()
    .connectTimeout(15, TimeUnit.SECONDS)
    .readTimeout(15, TimeUnit.SECONDS)
    .addInterceptor()
    .build()

 val newCall = okHttpClient.newCall(request)
 //異步請(qǐng)求數(shù)據(jù)
 newCall.enqueue(object :Callback{
 override fun onFailure(call: Call, e: IOException) {}
 override fun onResponse(call: Call, response: Response) {}
 })
 //同步請(qǐng)求數(shù)據(jù)
 val response = newCall.execute()

 /** Prepares the [request] to be executed at some point in the future. */
 override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

//RealCall#enqueue(responseCallback: Callback) 

 override fun enqueue(responseCallback: Callback) {
 synchronized(this) {
  //檢查這個(gè)call是否執(zhí)行過(guò)，每個(gè) call 只能被執(zhí)行一次
  check(!executed) { "Already Executed" }
  executed = true
 }
 //此方法調(diào)用了EventListener#callStart(call: Call)，
 主要是用來(lái)監(jiān)視應(yīng)用程序的HTTP調(diào)用的數(shù)量，大小和各個(gè)階段的耗時(shí)
 callStart()
 //創(chuàng)建AsyncCall,實(shí)際是個(gè)Runnable
 client.dispatcher.enqueue(AsyncCall(responseCallback))
 }

//Dispatcher#enqueue(call: AsyncCall)

 /** Ready async calls in the order they'll be run. */
 private val readyAsyncCalls = ArrayDeque<AsyncCall>()
 
 internal fun enqueue(call: AsyncCall) {
 synchronized(this) {
  //將call添加到即將運(yùn)行的異步隊(duì)列
  readyAsyncCalls.add(call)
  ...
  promoteAndExecute()
 }

//Dispatcher#promoteAndExecute() 
//將[readyAsyncCalls]過(guò)渡到[runningAsyncCalls]

 private fun promoteAndExecute(): Boolean {
 ...
 for (i in 0 until executableCalls.size) {
  val asyncCall = executableCalls[i]
  //這里就是通過(guò) ExecutorService 執(zhí)行 run()
  asyncCall.executeOn(executorService)
 }
 return isRunning
 }

//RealCall.kt中的內(nèi)部類

 internal inner class AsyncCall(
 private val responseCallback: Callback
 ) : Runnable {
 fun executeOn(executorService: ExecutorService) {
  ...
  //執(zhí)行Runnable
  executorService.execute(this)
  ...
 	}
 	
 override fun run() {
  threadName("OkHttp ${redactedUrl()}") {
  ...
  try {
   //兜兜轉(zhuǎn)轉(zhuǎn) 終于調(diào)用這個(gè)關(guān)鍵方法了
   val response = getResponseWithInterceptorChain()
   signalledCallback = true
   //通過(guò)之前傳入的接口回調(diào)數(shù)據(jù)
   responseCallback.onResponse(this@RealCall, response)
  } catch (e: IOException) {
   if (signalledCallback) {
   Platform.get().log("Callback failure for ${toLoggableString()}", Platform.INFO, e)
   } else {
   responseCallback.onFailure(this@RealCall, e)
   }
  } catch (t: Throwable) {
   cancel()
   if (!signalledCallback) {
   val canceledException = IOException("canceled due to $t")
   canceledException.addSuppressed(t)
   responseCallback.onFailure(this@RealCall, canceledException)
   }
   throw t
  } finally {
   //移除隊(duì)列
   client.dispatcher.finished(this)
  }
  }
 }
 }

 override fun execute(): Response {
 //同樣判斷是否執(zhí)行過(guò)
 synchronized(this) {
  check(!executed) { "Already Executed" }
  executed = true
 }
 timeout.enter()
 //同樣監(jiān)聽(tīng)
 callStart()
 try {
  //同樣執(zhí)行
  client.dispatcher.executed(this)
  return getResponseWithInterceptorChain()
 } finally {
  //同樣移除
  client.dispatcher.finished(this)
 }
 }

 @Throws(IOException::class)
 internal fun getResponseWithInterceptorChain(): Response {
 // 構(gòu)建完整的攔截器
 val interceptors = mutableListOf<Interceptor>()
 interceptors += client.interceptors     //用戶自己攔截器，數(shù)據(jù)最開(kāi)始和最后
 interceptors += RetryAndFollowUpInterceptor(client) //失敗后的重試和重定向
 interceptors += BridgeInterceptor(client.cookieJar) //橋接用戶的信息和服務(wù)器的信息
 interceptors += CacheInterceptor(client.cache)   //處理緩存相關(guān)
 interceptors += ConnectInterceptor      //負(fù)責(zé)與服務(wù)器連接
 if (!forWebSocket) {
  interceptors += client.networkInterceptors   //配置 OkHttpClient 時(shí)設(shè)置，數(shù)據(jù)未經(jīng)處理
 }
 interceptors += CallServerInterceptor(forWebSocket) //負(fù)責(zé)向服務(wù)器發(fā)送請(qǐng)求數(shù)據(jù)、從服務(wù)器讀取響應(yīng)數(shù)據(jù)
 //創(chuàng)建攔截鏈
 val chain = RealInterceptorChain(
  call = this,
  interceptors = interceptors,
  index = 0,
  exchange = null,
  request = originalRequest,
  connectTimeoutMillis = client.connectTimeoutMillis,
  readTimeoutMillis = client.readTimeoutMillis,
  writeTimeoutMillis = client.writeTimeoutMillis
 )

 var calledNoMoreExchanges = false
 try {
  //攔截鏈的執(zhí)行
  val response = chain.proceed(originalRequest)
 	 ...
 } catch (e: IOException) {
	 ...
 } finally {
	 ...
 }
 }

//1.RealInterceptorChain#proceed(request: Request)
@Throws(IOException::class)
 override fun proceed(request: Request): Response {
 ...
 // copy出新的攔截鏈，鏈中的攔截器集合index+1
 val next = copy(index = index + 1, request = request)
 val interceptor = interceptors[index]

 //調(diào)用攔截器的intercept(chain: Chain): Response 返回處理后的數(shù)據(jù) 交由下一個(gè)攔截器處理
 @Suppress("USELESS_ELVIS")
 val response = interceptor.intercept(next) ?: throw NullPointerException(
  "interceptor $interceptor returned null")
 ...
 //返回最終的響應(yīng)體
 return response
 }

@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) {
  ...//在調(diào)用下一個(gè)攔截器前的操作
  var response: Response
  try {
  ...
  try {
   //調(diào)用下一個(gè)攔截器
   response = realChain.proceed(request)
   newExchangeFinder = true
  } catch (e: RouteException) {
  ...
   continue
  } catch (e: IOException) {
   ...
   continue
  }

  ...
  //處理上一個(gè)攔截器返回的 response
  val followUp = followUpRequest(response, exchange)
	 ...
	 //中間有一些判斷是否需要重新請(qǐng)求 不需要?jiǎng)t返回 response
	 //處理之后重新請(qǐng)求 Request
  request = followUp
  priorResponse = response
  } finally {
  call.exitNetworkInterceptorExchange(closeActiveExchange)
  }
 }
 }
 
 @Throws(IOException::class)
 private fun followUpRequest(userResponse: Response, exchange: Exchange?): Request? {
 val route = exchange?.connection?.route()
 val responseCode = userResponse.code

 val method = userResponse.request.method
 when (responseCode) {
	 //3xx 重定向
  HTTP_PERM_REDIRECT, HTTP_TEMP_REDIRECT, HTTP_MULT_CHOICE, HTTP_MOVED_PERM, HTTP_MOVED_TEMP, HTTP_SEE_OTHER -> {
  //這個(gè)方法重新 構(gòu)建了 Request 用于重新請(qǐng)求
  return buildRedirectRequest(userResponse, method)
  }
	 ... 省略一部分code
  else -> return null
 }
 }

 @Throws(IOException::class)
 override fun intercept(chain: Interceptor.Chain): Response {
 //在Cache(DiskLruCache)類中 通過(guò)request.url匹配response
 val cacheCandidate = cache?.get(chain.request())
 //記錄當(dāng)前時(shí)間點(diǎn)
 val now = System.currentTimeMillis()
 //緩存策略 有兩種類型 
 //networkRequest 網(wǎng)絡(luò)請(qǐng)求
 //cacheResponse 緩存的響應(yīng)
 val strategy = CacheStrategy.Factory(now, chain.request(), cacheCandidate).compute()
 val networkRequest = strategy.networkRequest
 val cacheResponse = strategy.cacheResponse
 //計(jì)算請(qǐng)求次數(shù)和緩存次數(shù)
 cache?.trackResponse(strategy)
 ...
 // 如果 禁止使用網(wǎng)絡(luò) 并且 緩存不足，返回504和空body的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()
 }

 // 如果策略中不能使用網(wǎng)絡(luò)，就把緩存中的response封裝返回
 if (networkRequest == null) {
  return cacheResponse!!.newBuilder()
   .cacheResponse(stripBody(cacheResponse))
   .build()
 }
 //調(diào)用攔截器process從網(wǎng)絡(luò)獲取數(shù)據(jù)
 var networkResponse: Response? = null
 try {
  networkResponse = chain.proceed(networkRequest)
 } finally {
  // If we're crashing on I/O or otherwise, don't leak the cache body.
  if (networkResponse == null && cacheCandidate != null) {
  cacheCandidate.body?.closeQuietly()
  }
 }
 
 //如果有緩存的Response
 if (cacheResponse != null) {
  //如果網(wǎng)絡(luò)請(qǐng)求返回code為304 即說(shuō)明資源未修改
  if (networkResponse?.code == HTTP_NOT_MODIFIED) {
  //直接封裝封裝緩存的Response返回即可
  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
  } else {
  cacheResponse.body?.closeQuietly()
  }
 }

 val response = networkResponse!!.newBuilder()
  .cacheResponse(stripBody(cacheResponse))
  .networkResponse(stripBody(networkResponse))
  .build()

 if (cache != null) {
  //判斷是否具有主體 并且 是否可以緩存供后續(xù)使用
  if (response.promisesBody() && CacheStrategy.isCacheable(response, networkRequest)) {
  // 加入緩存中
  val cacheRequest = cache.put(response)
  return cacheWritingResponse(cacheRequest, response)
  }
  //如果請(qǐng)求方法無(wú)效 就從緩存中remove掉
  if (HttpMethod.invalidatesCache(networkRequest.method)) {
  try {
   cache.remove(networkRequest)
  } catch (_: IOException) {
   // The cache cannot be written.
  }
  }
 }
 
 return response
 }

@Throws(IOException::class)
 override fun intercept(chain: Interceptor.Chain): Response {
 val realChain = chain as RealInterceptorChain
 val exchange = realChain.call.initExchange(chain)
 val connectedChain = realChain.copy(exchange = exchange)
 return connectedChain.proceed(realChain.request)
 }

/** Finds a new or pooled connection to carry a forthcoming request and response. */
 internal fun initExchange(chain: RealInterceptorChain): Exchange {
	...
	//codec是對(duì) HTTP 協(xié)議操作的抽象，有兩個(gè)實(shí)現(xiàn)：Http1Codec和Http2Codec，對(duì)應(yīng) HTTP/1.1 和 HTTP/2。
 val codec = exchangeFinder.find(client, chain)
 val result = Exchange(this, eventListener, exchangeFinder, codec)
 ...
 return result
 }
 
 #ExchangeFinder.find
 fun find(client: OkHttpClient,chain: RealInterceptorChain):ExchangeCodec {
 try {
  //尋找一個(gè)可用的連接
  val resultConnection = findHealthyConnection(
   connectTimeout = chain.connectTimeoutMillis,
   readTimeout = chain.readTimeoutMillis,
   writeTimeout = chain.writeTimeoutMillis,
   pingIntervalMillis = client.pingIntervalMillis,
   connectionRetryEnabled = client.retryOnConnectionFailure,
   doExtensiveHealthChecks = chain.request.method != "GET"
  )
  return resultConnection.newCodec(client, chain)
 } catch (e: RouteException) {
  trackFailure(e.lastConnectException)
  throw e
 } catch (e: IOException) {
  trackFailure(e)
  throw RouteException(e)
 }
 }
 
 @Throws(IOException::class)
 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
  )

  //確認(rèn)找到的連接可用并返回
  if (candidate.isHealthy(doExtensiveHealthChecks)) {
  return candidate
  }
	 ...
  throw IOException("exhausted all routes")
 }
 }
 
 @Throws(IOException::class)
 private fun findConnection(
 connectTimeout: Int,
 readTimeout: Int,
 writeTimeout: Int,
 pingIntervalMillis: Int,
 connectionRetryEnabled: Boolean
 ): RealConnection {
 if (call.isCanceled()) throw IOException("Canceled")

 // 1. 嘗試重用這個(gè)call的連接 比如重定向需要再次請(qǐng)求 那么這里就會(huì)重用之前的連接
 val callConnection = call.connection
 if (callConnection != null) {
  var toClose: Socket? = null
  synchronized(callConnection) {
  if (callConnection.noNewExchanges || !sameHostAndPort(callConnection.route().address.url)) {
   toClose = call.releaseConnectionNoEvents()
  }
  }
	 //返回這個(gè)連接
  if (call.connection != null) {
  check(toClose == null)
  return callConnection
  }

  // The call's connection was released.
  toClose?.closeQuietly()
  eventListener.connectionReleased(call, callConnection)
 }
	...
 // 2. 嘗試從連接池中找一個(gè)連接 找到就返回連接
 if (connectionPool.callAcquirePooledConnection(address, call, null, false)) {
  val result = call.connection!!
  eventListener.connectionAcquired(call, result)
  return result
 }

 // 3. 如果連接池中沒(méi)有 計(jì)算出下一次要嘗試的路由
 val routes: List<Route>?
 val route: Route
 if (nextRouteToTry != null) {
  // Use a route from a preceding coalesced connection.
  routes = null
  route = nextRouteToTry!!
  nextRouteToTry = null
 } else if (routeSelection != null && routeSelection!!.hasNext()) {
  // Use a route from an existing route selection.
  routes = null
  route = routeSelection!!.next()
 } else {
  // Compute a new route selection. This is a blocking operation!
  var localRouteSelector = routeSelector
  if (localRouteSelector == null) {
  localRouteSelector = RouteSelector(address, call.client.routeDatabase, call, eventListener)
  this.routeSelector = localRouteSelector
  }
  val localRouteSelection = localRouteSelector.next()
  routeSelection = localRouteSelection
  routes = localRouteSelection.routes

  if (call.isCanceled()) throw IOException("Canceled")

  // Now that we have a set of IP addresses, make another attempt at getting a connection from
  // the pool. We have a better chance of matching thanks to connection coalescing.
  if (connectionPool.callAcquirePooledConnection(address, call, routes, false)) {
  val result = call.connection!!
  eventListener.connectionAcquired(call, result)
  return result
  }

  route = localRouteSelection.next()
 }

 // Connect. Tell the call about the connecting call so async cancels work.
 // 4.到這里還沒(méi)有找到可用的連接 但是找到了 route 即路由 進(jìn)行socket/tls連接
 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())

 // If we raced another call connecting to this host, coalesce the connections. This makes for 3
 // different lookups in the connection pool!
 // 4.查找是否有多路復(fù)用(http2)的連接,有就返回
 if (connectionPool.callAcquirePooledConnection(address, call, routes, true)) {
  val result = call.connection!!
  nextRouteToTry = route
  newConnection.socket().closeQuietly()
  eventListener.connectionAcquired(call, result)
  return result
 }

 synchronized(newConnection) {
  //放入連接池中
  connectionPool.put(newConnection)
  call.acquireConnectionNoEvents(newConnection)
 }

 eventListener.connectionAcquired(call, newConnection)
 return newConnection
 }
 

fun connect(
 connectTimeout: Int,
 readTimeout: Int,
 writeTimeout: Int,
 pingIntervalMillis: Int,
 connectionRetryEnabled: Boolean,
 call: Call,
 eventListener: EventListener
 ) {
 ...
 while (true) {
  try {
  if (route.requiresTunnel()) {
   //創(chuàng)建tunnel，用于通過(guò)http代理訪問(wèn)https
   //其中包含connectSocket、createTunnel
   connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener)
   if (rawSocket == null) {
   // We were unable to connect the tunnel but properly closed down our resources.
   break
   }
  } else {
   //不創(chuàng)建tunnel就創(chuàng)建socket連接 獲取到數(shù)據(jù)流
   connectSocket(connectTimeout, readTimeout, call, eventListener)
  }
  //建立協(xié)議連接tsl
  establishProtocol(connectionSpecSelector, pingIntervalMillis, call, eventListener)
  eventListener.connectEnd(call, route.socketAddress, route.proxy, protocol)
  break
  } catch (e: IOException) {
  ...
  }
 }
	...
 }

@Throws(IOException::class)
 private fun establishProtocol(
 connectionSpecSelector: ConnectionSpecSelector,
 pingIntervalMillis: Int,
 call: Call,
 eventListener: EventListener
 ) {
 	//ssl為空 即http請(qǐng)求 明文請(qǐng)求
 if (route.address.sslSocketFactory == null) {
  if (Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols) {
  socket = rawSocket
  protocol = Protocol.H2_PRIOR_KNOWLEDGE
  startHttp2(pingIntervalMillis)
  return
  }

  socket = rawSocket
  protocol = Protocol.HTTP_1_1
  return
 }
	//否則為https請(qǐng)求 需要連接sslSocket 驗(yàn)證證書(shū)是否可被服務(wù)器接受 保存tsl返回的信息
 eventListener.secureConnectStart(call)
 connectTls(connectionSpecSelector)
 eventListener.secureConnectEnd(call, handshake)

 if (protocol === Protocol.HTTP_2) {
  startHttp2(pingIntervalMillis)
 }
 }