okHttp源碼解讀(一)
okHttp 出來有一段時間了，也不是沒用過而是沒在項目中實際用過，現在新項目就用了這個網絡請求框架，在項目中作了簡單的封裝和使用，對於源碼我過了一遍，主要看總體流程，更容易把握總體架構。promise
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.ktcookie
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關鍵方法就是：proceedRealInterceptorChain.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 也作必定的處理轉化；app
- 註釋（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
}
複製代碼
基本就是發起網絡請求了以及對各類返回碼的處理，我在網上找到關於攔截器之間的一個動態圖，挺形象的：
相關文章
- 1. okhttp源碼解讀
- 2. okHttp源碼閱讀
- 3. Okhttp源碼解析(一)
- 4. OkHttp源碼解析（一）
- 5. OKHttp源碼解析（一）
- 6. 一步步帶你讀懂 Okhttp 源碼
- 7. 源碼解析OkHttp
- 8. OKHttp源碼解析
- 9. OkHttp源碼解析
- 10. Okhttp源碼解析
- 更多相關文章...
- • Docker 資源彙總 - Docker教程
- • Java操作Neo4j數據庫（附帶源碼） - NoSQL教程
- • JDK13 GA發佈：5大特性解讀
- • Scala 中文亂碼解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. js中 charCodeAt
- 2. Android中通過ViewHelper.setTranslationY實現View移動控制（NineOldAndroids開源項目）
- 3. 【Android】日常記錄：BottomNavigationView自定義樣式，修改點擊後圖片
- 4. maya 文件檢查 ui和數據分離 （一）
- 5. eclipse 修改項目的jdk版本
- 6. Android InputMethod設置
- 7. Simulink中Bus Selector出現很多? ? ?
- 8. 【Openfire筆記】啓動Mac版Openfire時提示「系統偏好設置錯誤」
- 9. AutoPLP在偏好標籤中的生產與應用
- 10. 數據庫關閉的四種方式
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. okhttp源碼解讀
- 2. okHttp源碼閱讀
- 3. Okhttp源碼解析(一)
- 4. OkHttp源碼解析（一）
- 5. OKHttp源碼解析（一）
- 6. 一步步帶你讀懂 Okhttp 源碼
- 7. 源碼解析OkHttp
- 8. OKHttp源碼解析
- 9. OkHttp源碼解析
- 10. Okhttp源碼解析