okHttp源碼解讀(一)

okHttp 出來有一段時間了，也不是沒用過而是沒在項目中實際用過，如今新項目就用了這個網絡框架，在項目中做了簡單的封裝和使用，對於源碼我過了一遍，主要看整體流程，更容易把握整體架構。

1. 整體流程

構建 okHttpClient -------->構建 Request.Builder ----------->發送請求，構建Call（RealCall）,有同步（execute）和 異步（enqueue）請求 -------------> Dispatcher
---------> InterceptorChain -------------> 獲取 response 再返回；

2. 攔截器

在看這個源碼的時候，我主要看的是這個攔截器部分 ；攔截器得從請求入口那裏說起；

RealCall.kt

//無論是同步請求還是異步請求，都差不多,這裏以同步爲例；
override fun execute(): Response {
    synchronized(this) {
      check(!executed) { "Already Executed" }
      executed = true
    }
    transmitter.timeoutEnter()
    transmitter.callStart()
    try {
      client.dispatcher.executed(this) ----------->(1)
      return getResponseWithInterceptorChain() ------------->(2)
    } finally {
      client.dispatcher.finished(this)
    }
  }

• 註釋（1）處：表示把當前的請求（call）添加到隊列中去，（runningSyncCalls ：ArrayDeque<RealCall>() ）
• 註釋（2）處：getResponseWithInterceptorChain() 調用獲取這個 攔截器鏈並獲取結果 返回，主要就是這個方法。

RealCall.kt

fun getResponseWithInterceptorChain(): Response {
    // Build a full stack of interceptors.
    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(interceptors, transmitter, null, 0, originalRequest, this,
        client.connectTimeoutMillis, client.readTimeoutMillis, 
client.writeTimeoutMillis) -------->(1)

    var calledNoMoreExchanges = false
    try {
      val response = chain.proceed(originalRequest) ---------->(2)
      if (transmitter.isCanceled) {
        response.closeQuietly()
        throw IOException("Canceled")
      }
      return response
    } catch (e: IOException) {
        ...
    } finally {
      ....
    }
  }

• 在代碼的一開始構建了攔截器的集合，interceptors ,分別按照順序，依次添加了 :
  攔截器1：RetryAndFollowUpInterceptor
  攔截器2： BridgeInterceptor
  攔截器3：CacheInterceptor
  攔截器4：ConnecInterceptor
  攔截器5：CallServerInterceptor
  而後就構建了 RealInterceptorChain ----->chain 在註釋（1）處 ；
  在註釋（2）處，調用 chain.proceed(originalRequest) 返回 response
  關鍵方法就是：proceed
RealInterceptorChain.kt

fun proceed(request: Request, transmitter: Transmitter, exchange: Exchange?): Response {
    if (index >= interceptors.size) throw AssertionError()

    calls++
    ...

    // Call the next interceptor in the chain.
    val next = RealInterceptorChain(interceptors, transmitter, exchange,
        index + 1, request, call, connectTimeout, readTimeout, writeTimeout) -------->(1)
    val interceptor = interceptors[index]   ------->(2)

    @Suppress("USELESS_ELVIS")
    val response = interceptor.intercept(next) ?: throw NullPointerException(
        "interceptor $interceptor returned null") ---------->(3)

    // Confirm that the next interceptor made its required call to chain.proceed().
    check(exchange == null || 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
  }

• 註釋（1）處，我們看到 第四個參數 ：index+1 ,之前的時候我們傳入的是0 ，這個表示取出下一個 RealInterceptorChain ;
• 在註釋（2）處，取出當前的攔截器：interceptor
• 在註釋（3）處，調用攔截器的 intercept 攔截方法，並將下一個攔截器傳入進去 ；
  每一個攔截器都是 繼承於 Interceptor 並 重寫 interceptor 方法 ；如果要自定義攔截器也是如此；

2.1 第一個攔截器也就是：RetryAndFollowUpInterceptor

RetryAndFollowUpInterceptor.kt

/**關於該攔截器的介紹
 * This interceptor recovers from failures and follows redirects as necessary. It may throw an
 * [IOException] if the call was canceled.
就是說會從失敗中恢復並且在必要的時候重定向，如果請求被取消可能會拋出IOException.
 */
override fun intercept(chain: Interceptor.Chain): Response {
    var request = chain.request()  ------>取出request
    val realChain = chain as RealInterceptorChain  
    val transmitter = realChain.transmitter()
    var followUpCount = 0
    var priorResponse: Response? = null --------->重定向前的 response
    while (true) {  ------> 這裏是個死循環
      transmitter.prepareToConnect(request)

      if (transmitter.isCanceled) {
        throw IOException("Canceled")
      }

      var response: Response
      var success = false
      try {
        response = realChain.proceed(request, transmitter, null) --------> 這裏鏈式調用，就傳遞到下一個攔截器，也是調用下個攔截器的 interceptor 方法
        success = true
      } catch (e: RouteException) {
        // The attempt to connect via a route failed. The request will not have been sent.
        如果路由失敗，請求不會再次發送
        if (!recover(e.lastConnectException, transmitter, false, request)) {
          throw e.firstConnectException
        }
        continue
      } catch (e: IOException) {
        // An attempt to communicate with a server failed. The request may have been sent.如果與服務器交流建立鏈接失敗，可能會重新發送請求
        val requestSendStarted = e !is ConnectionShutdownException
        if (!recover(e, transmitter, requestSendStarted, request)) throw e
        continue
      } finally {
        // The network call threw an exception. Release any resources.
        if (!success) {
          transmitter.exchangeDoneDueToException()
        }
      }

      // Attach the prior response if it exists. Such responses never have a body.
      這裏嘗試獲取之前的response，如果存在的，這樣的response 沒有body,可以看到 body 置爲了 null ;
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                .body(null)
                .build())
            .build()
      }

      val exchange = response.exchange
      val route = exchange?.connection()?.route()
      val followUp = followUpRequest(response, route)

      if (followUp == null) {
        if (exchange != null && exchange.isDuplex) {
          transmitter.timeoutEarlyExit()
        }
        return response
      }

      val followUpBody = followUp.body
      if (followUpBody != null && followUpBody.isOneShot()) {
        return response
      }

      response.body?.closeQuietly()
      if (transmitter.hasExchange()) {
        exchange?.detachWithViolence()
      }

      if (++followUpCount > MAX_FOLLOW_UPS) {
        throw ProtocolException("Too many follow-up requests: $followUpCount")
      }

      request = followUp
      priorResponse = response ----->這裏對priResponse 賦值
    }
  }

2.2 攔截器2：BridgeInterceptor

BridgeInterceptor.kt

/**就是把用戶請求轉化爲網絡（network）請求, 把服務器響應轉化爲用戶友好的響應
 * Bridges from application code to network code. First it builds a network request from a user
 * request. Then it proceeds to call the network. Finally it builds a user response from the network
 * response.
 */
override fun intercept(chain: Interceptor.Chain): Response {
    val userRequest = chain.request()
    val requestBuilder = userRequest.newBuilder()

    val body = userRequest.body
    if (body != null) {
      val contentType = body.contentType()
      if (contentType != null) {
        requestBuilder.header("Content-Type", contentType.toString()) ----->(1)
      }

      val contentLength = body.contentLength()
      if (contentLength != -1L) {
        requestBuilder.header("Content-Length", contentLength.toString()) ----->(2)
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")
        requestBuilder.removeHeader("Content-Length")
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", userRequest.url.toHostHeader())----->(3)
    }

    if (userRequest.header("Connection") == null) {
      requestBuilder.header("Connection", "Keep-Alive")----->(4)
    }

    // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
    // the transfer stream.
    var transparentGzip = false
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true
      requestBuilder.header("Accept-Encoding", "gzip")
    }

    val cookies = cookieJar.loadForRequest(userRequest.url)
    if (cookies.isNotEmpty()) {
      requestBuilder.header("Cookie", cookieHeader(cookies))----->(5)
    }

    if (userRequest.header("User-Agent") == null) {
      requestBuilder.header("User-Agent", userAgent)----->(6)
    }

    val networkResponse = chain.proceed(requestBuilder.build()) -------->(7)

    cookieJar.receiveHeaders(userRequest.url, networkResponse.headers)

    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()
        responseBuilder.headers(strippedHeaders)
        val contentType = networkResponse.header("Content-Type")
        responseBuilder.body(RealResponseBody(contentType, -1L, gzipSource.buffer()))
      }
    }

    return responseBuilder.build()
  }

這個每個不同的攔截器都有自己不同的處理，這裏這個攔截器主要就是對 用戶發出的request 轉化爲服務器需要的 request , 同樣 response 也做一定的處理轉化；

• 註釋（1）-（6）都是在做這樣的轉化，看名字：userRequest -----> requestBuilder
• 註釋（7）就又是鏈式調用下一個攔截器了 得到 networkResponse
• 下面就是拿到 networkResponse 進行轉化了，轉變爲------> responseBuilder

2.3 攔截器3：CacheInterceptor

CacheInterceptor.kt

/** Serves requests from the cache and writes responses to the cache. */
從緩存獲取請求，並且將response寫入緩存 ,這跟你在構建 OKHttpClinent 是否設置緩存有關
override fun intercept(chain: Interceptor.Chain): Response {
    val cacheCandidate = cache?.get(chain.request())

    val now = System.currentTimeMillis()

    val strategy = CacheStrategy.Factory(now, chain.request(), cacheCandidate).compute()
    val networkRequest = strategy.networkRequest
    val cacheResponse = strategy.cacheResponse

    cache?.trackResponse(strategy)

    if (cacheCandidate != null && cacheResponse == null) { ------->（1）
      // The cache candidate wasn't applicable. Close it.
      cacheCandidate.body?.closeQuietly()
    }

   //下面就是對各種緩存策略的判斷處理
    // If we're forbidden from using the network and the cache is insufficient, fail.
    if (networkRequest == null && cacheResponse == null) {-------->（2）
      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()
    }

    // If we don't need the network, we're done.
    if (networkRequest == null) {----------> （3）
      return cacheResponse!!.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build()
    }

    var networkResponse: Response? = null
    try {
      networkResponse = chain.proceed(networkRequest)  --------> （4）
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        cacheCandidate.body?.closeQuietly()
      }
    }

    // If we have a cache response too, then we're doing a conditional get.
    if (cacheResponse != null) {
      if (networkResponse?.code == HTTP_NOT_MODIFIED) {--------->（5）
        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() ---------> （6）

    if (cache != null) {
      if (response.promisesBody() && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        val cacheRequest = cache.put(response)
        return cacheWritingResponse(cacheRequest, response)
      }

      if (HttpMethod.invalidatesCache(networkRequest.method)) {
        try {
          cache.remove(networkRequest)
        } catch (_: IOException) {
          // The cache cannot be written.
        }
      }
    }

    return response
  }

• 註釋（1）：有緩存但是不允許緩存 ；
• 註釋（2）：networkRequest == null && cacheResponse == null 根據註釋說明 If we're forbidden from using the network and the cache is insufficient, fail 就是說如果我們禁止從網絡獲取並且也無緩存，那就失敗了，構建相應的 response ; body 我們能看到是 EMPTY_RESPONSE ;
• 註釋（3）：If we don't need the network, we're done 表示有緩存，如果我們設置了不從網絡加載數據，那麼也構建相應的 response ；
• 註釋（4）：同樣調用下個攔截器的 interceptor 方法 ；
• 註釋（5）：判斷網絡得到的 response ,是否修改，是否要更新緩存，如果修改了就更新緩存 ；
• 註釋（6）：構建返回的 response

2.4 攔截器4：ConnectInterceptor

ConnectInterceptor.kt

該攔截器主要就負責與服務器建立連接，然後繼續下個攔截器
/** Opens a connection to the target server and proceeds to the next interceptor. */
override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val request = realChain.request()
    val transmitter = realChain.transmitter()

    // We need the network to satisfy this request. Possibly for validating a conditional GET.我們需要此次請求是安全的，可能會先驗證一下 get 請求
    val doExtensiveHealthChecks = request.method != "GET"
    val exchange = transmitter.newExchange(chain, doExtensiveHealthChecks)

    return realChain.proceed(request, transmitter, exchange)
  }

這個建立與服務器建立連接，在 newExchange 中，一直跟着找能發現以下的代碼：

internal fun newCodec(client: OkHttpClient, chain: Interceptor.Chain): ExchangeCodec {
    val socket = this.socket!!
    val source = this.source!!
    val sink = this.sink!!
    val http2Connection = this.http2Connection

    return if (http2Connection != null) {
      Http2ExchangeCodec(client, this, chain, http2Connection)
    } else {
      socket.soTimeout = chain.readTimeoutMillis()
      source.timeout().timeout(chain.readTimeoutMillis().toLong(), MILLISECONDS)
      sink.timeout().timeout(chain.writeTimeoutMillis().toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, source, sink)
    }
  }

根據不同的 http 協議，分別就是：
Http1ExchangeCodec : http1.1 ;
Http2ExchangeCodec ：http2.0 ;
做不同的處理 ；

2.5 攔截器5：CallServerInterceptor

CallServerInterceptor.kt

這是鏈式調用的最後一個攔截器，會向服務器發送一個請求
/** This is the last interceptor in the chain. It makes a network call to the server. */
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.exchange()
    val request = realChain.request()
    val requestBody = request.body
    val sentRequestMillis = System.currentTimeMillis()

    exchange.writeRequestHeaders(request)

    var responseHeadersStarted = false
    var responseBuilder: Response.Builder? = null
    if (HttpMethod.permitsRequestBody(request.method) && requestBody != 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 ("100-continue".equals(request.header("Expect"), ignoreCase = true)) {
        exchange.flushRequest()
        responseHeadersStarted = true
        exchange.responseHeadersStart()
        responseBuilder = exchange.readResponseHeaders(true)
      }
      if (responseBuilder == null) {
        if (requestBody.isDuplex()) {
          // Prepare a duplex body so that the application can send a request body later.
          exchange.flushRequest()
          val bufferedRequestBody = exchange.createRequestBody(request, true).buffer()
          requestBody.writeTo(bufferedRequestBody)
        } else {
          // Write the request body if the "Expect: 100-continue" expectation was met.
          val bufferedRequestBody = exchange.createRequestBody(request, false).buffer()
          requestBody.writeTo(bufferedRequestBody)
          bufferedRequestBody.close()
        }
      } else {
        exchange.noRequestBody()
        if (!exchange.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.
          exchange.noNewExchangesOnConnection()
        }
      }
    } else {
      exchange.noRequestBody()
    }

    if (requestBody == null || !requestBody.isDuplex()) {
      exchange.finishRequest()
    }
    if (!responseHeadersStarted) {
      exchange.responseHeadersStart()
    }
    if (responseBuilder == null) {
      responseBuilder = exchange.readResponseHeaders(false)!!
    }
    var response = responseBuilder
        .request(request)
        .handshake(exchange.connection()!!.handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build()
    var code = response.code
    if (code == 100) {
      // server sent a 100-continue even though we did not request one.
      // try again to read the actual response
      response = exchange.readResponseHeaders(false)!!
          .request(request)
          .handshake(exchange.connection()!!.handshake())
          .sentRequestAtMillis(sentRequestMillis)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build()
      code = response.code
    }

    exchange.responseHeadersEnd(response)

    response = if (forWebSocket && code == 101) {
      // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
      response.newBuilder()
          .body(EMPTY_RESPONSE)
          .build()
    } else {
      response.newBuilder()
          .body(exchange.openResponseBody(response))
          .build()
    }
    if ("close".equals(response.request.header("Connection"), ignoreCase = true) ||
        "close".equals(response.header("Connection"), ignoreCase = true)) {
      exchange.noNewExchangesOnConnection()
    }
    if ((code == 204 || code == 205) && response.body?.contentLength() ?: -1L > 0L) {
      throw ProtocolException(
          "HTTP $code had non-zero Content-Length: ${response.body?.contentLength()}")
    }
    return response
  }

基本就是發起網絡請求了以及對各種返回碼的處理，我在網上找到關於攔截器之間的一個動態圖，挺形象的：