okHttp 出來有一段時間了,也不是沒用過而是沒在項目中實際用過,現在新項目就用了這個網絡請求框架,在項目中作了簡單的封裝和使用,對於源碼我過了一遍,主要看總體流程,更容易把握總體架構。promise
構建 okHttpClient
-------->構建 Request.Builder
----------->發送請求,構建Call(RealCall),有同步(execute)和 異步(enqueue)請求 -------------> Dispatcher
---------> InterceptorChain
-------------> 獲取 response
再返回;緩存
在看這個源碼的時候,我主要看的是這個攔截器部分 ;攔截器得從請求入口那裏提及;安全
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)
}
}
複製代碼
(runningSyncCalls :ArrayDeque<RealCall>() )
getResponseWithInterceptorChain()
調用獲取這個 攔截器鏈並獲取結果 返回,主要就是這個方法。RealCall.kt
cookie
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
}
複製代碼
RealInterceptorChain
;interceptor
intercept
攔截方法,並將下一個攔截器傳入進去 ; 每個攔截器都是 繼承於 Interceptor
並 重寫 interceptor
方法 ;若是要自定義攔截器也是如此;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 賦值
}
}
複製代碼
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
userRequest
-----> requestBuildernetworkResponse
networkResponse
進行轉化了,轉變爲------> responseBuilder
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
}
複製代碼
networkRequest == null && cacheResponse == null
根據註釋說明 If we're forbidden from using the network and the cache is insufficient, fail
就是說若是咱們禁止從網絡獲取而且也無緩存,那就失敗了,構建相應的 response
; body 咱們能看到是 EMPTY_RESPONSE
;If we don't need the network, we're done
表示有緩存,若是咱們設置了不從網絡加載數據,那麼也構建相應的 response
;interceptor
方法 ;response
,是否修改,是否要更新緩存,若是修改了就更新緩存 ;response
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
; 作不一樣的處理 ;
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
}
複製代碼
基本就是發起網絡請求了以及對各類返回碼的處理,我在網上找到關於攔截器之間的一個動態圖,挺形象的: