OkHttp应该是目前Android平台上使用最为广泛的开源网络库了，Android 在6.0之后也将内部的HttpUrlConnection的默认实现替换成了OkHttp。
网上很多分析OkHttp的，都是在总体流程上，没有那么的细致，甚至有的同学看完了文章，认为OkHttp没有DNS解析。所以本系列会深入源码，既掌握结构，也了解细节
下面的代码是一个很简单的例子，一步一步分析，起内部的工作原理
我要评论 OkHttpClient client = new OkHttpClient();
// Create request for remote resource.
Request request = new Request.Builder()
.url(ENDPOINT)
.build();
// Execute the request and retrieve the response.
Response response = client.newCall(request).execute()
OkHttp 的整体架构是很简单的，Request 作为请求， Response作为响应，在RealCall 中处理同步异步请求，处理过程就是一系列的拦截器。
图片来自
open class OkHttpClient internal constructor(
builder: Builder
) : Cloneable, Call.Factory, WebSocket.Factory {
// 使用默认的Builder 来创建OkHttpClient
constructor() : this(Builder())
...省略代码...
init {
...省略代码...
//获取证书信任管理器
this.x509TrustManager = Platform.get().platformTrustManager()
//用指定的证书信任管理器，来创建一个sslSocket工厂
this.sslSocketFactoryOrNull =Platform.get().newSslSocketFactory(x509TrustManager!!)
//省略与TLS握手无关的意外证书，并提取受信任的CA证书以使证书固定。
this.certificateChainCleaner = CertificateChainCleaner.get(x509TrustManager!!)
//用来限制哪些证书可以被信任
this.certificatePinner = builder.certificatePinner
.withCertificateChainCleaner(certificateChainCleaner!!)
...省略代码...
verifyClientState()
}
/** Prepares the [request] to be executed at some point in the future. */
override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)
...省略代码...
//Builder 模式，可以定制OkHttp
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()
//事件监听，一些事件发生后，回调该接口，比如网络链接成功，tls握手成功，dns解析开始结束等，
internal var eventListenerFactory: EventListener.Factory = EventListener.NONE.asFactory()
//cookie
internal var cookieJar: CookieJar = CookieJar.NO_COOKIES
//缓存
internal var cache: Cache? = null
//解析dns的类
internal var dns: Dns = Dns.SYSTEM
//通过代理来访问网络，例如，socket代理，http代理等 ，通过http代理 访问https，需要建立通道 Tunnel
internal var proxy: Proxy? = null
//代理选择器
internal var proxySelector: ProxySelector? = null
internal var proxyAuthenticator: Authenticator = Authenticator.NONE
//负责创建socket连接
internal var socketFactory: SocketFactory = SocketFactory.getDefault()
//负责创建SSLSocket连接 ,若无指定，在初始化OkHttp的时候 被赋值
internal var sslSocketFactoryOrNull: SSLSocketFactory? = null
//X509证书信任管理器，若无指定，在初始化OkHttp的时候 被赋值
internal var x509TrustManagerOrNull: X509TrustManager? = null
internal var connectionSpecs: List<ConnectionSpec> = DEFAULT_CONNECTION_SPECS
internal var protocols: List<Protocol> = DEFAULT_PROTOCOLS
internal var hostnameVerifier: HostnameVerifier = OkHostnameVerifier
//用来限制哪些证书可以被信任
internal var certificatePinner: CertificatePinner = CertificatePinner.DEFAULT
//省略与TLS握手无关的意外证书，并提取受信任的CA证书以使证书固定。
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
//每一个Route 对应一个Url 链接
internal var routeDatabase: RouteDatabase? = null
...省略代码...
}
}
示例中，调用newCall后，创建了RealCall 对象，调用execute() 执行同步请求，调用enqueue 执行异步请求
//同步操作，
override fun execute(): Response {
check(executed.compareAndSet(false, true)) { "Already Executed" }
timeout.enter()
callStart()
try {
//这里的dispatcher 是在创建OkHttp 的时候创建的
//因为这个是同步请求操作，所以executed 只是把RealCall对象放入到runningSyncCalls 堆中，表示正在进行
client.dispatcher.executed(this)
//所有的拦截器都在这里执行，OkHttp 的核心就是拦截器，所有的操作都是以拦截器的形式（责任链模式），例如Dns解析，socket连接，tls连接，缓存，网络请求，自定义拦截器等等
return getResponseWithInterceptorChain()
} finally {
//把RealCall对象从runningSyncCalls 堆中删除，并调用promoteAndExecute() ,来执行已经准备好的异步操作
client.dispatcher.finished(this)
}
}
// 异步操作，因为是异步的，所以需要设置回调接口
override fun enqueue(responseCallback: Callback) {
check(executed.compareAndSet(false, true)) { "Already Executed" }
callStart()
//用回调接口创建一个AsyncCall对象，下面介绍AsyncCall
//enqueue 只是把该请求对象，放入readyAsyncCalls堆中，然后调用promoteAndExecute()
client.dispatcher.enqueue(AsyncCall(responseCallback))
}
下面到Dispatcher 中 去看看
internal fun enqueue(call: AsyncCall) {
synchronized(this) {
// 把异步请求，加入到堆中
readyAsyncCalls.add(call)
...省略代码...
}
//处理异步请求
promoteAndExecute()
}
private fun promoteAndExecute(): Boolean {
this.assertThreadDoesntHoldLock()
val executableCalls = mutableListOf<AsyncCall>()
val isRunning: Boolean
synchronized(this) {
//从堆中拿出异步请求对象
val i = readyAsyncCalls.iterator()
while (i.hasNext()) {
val asyncCall = i.next()
if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.
if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // Host max capacity.
i.remove()
asyncCall.callsPerHost.incrementAndGet()
//如果符合上面的两个条件，就把异步请求加入到executableCalls
executableCalls.add(asyncCall)
runningAsyncCalls.add(asyncCall)
}
isRunning = runningCallsCount() > 0
}
for (i in 0 until executableCalls.size) {
val asyncCall = executableCalls[i]
//在线程池中依次执行 asyncCall
asyncCall.executeOn(executorService)
}
return isRunning
}
异步请求对象AsyncCall
internal inner class AsyncCall(
private val responseCallback: Callback
) : Runnable {
...省略代码...
/**
* Attempt to enqueue this async call on [executorService]. This will attempt to clean up
* if the executor has been shut down by reporting the call as failed.
*/
fun executeOn(executorService: ExecutorService) {
client.dispatcher.assertThreadDoesntHoldLock()
var success = false
try {
// 通过线程池，来调用AsyncCall，它是继承自Runnable，真正的实现在run函数中
executorService.execute(this)
success = true
} catch (e: RejectedExecutionException) {
...省略代码...
} finally {
if (!success) {
client.dispatcher.finished(this) // This call is no longer running!
}
}
}
override fun run() {
threadName("OkHttp ${redactedUrl()}") {
var signalledCallback = false
timeout.enter()
try {
//和同步请求一样的处理方式，返回处理结果
val response = getResponseWithInterceptorChain()
signalledCallback = true
//通过回调接口来返回请求结果，这里实在线程中返回的，所以不能直接在回调接口中进行UI操作
responseCallback.onResponse(this@RealCall, response)
} catch (e: IOException) {
...省略代码...
} finally {
client.dispatcher.finished(this)
}
}
}
}
网络请求的大概流程，算是搞清楚了，接下来就来看看OkHttp核心——拦截器
这里主要分析，所有的拦截器是如何进行组织，链式调用的 ，具体每个拦截器的处理方式先不展开
一图胜千言，拦截器的调用，在拦截器A的任意位置，对用拦截器B，在B返回后，可继续执行A
图片来源
从前面的同步请求和异步请求可以看出，最终都是要调用getResponseWithInterceptorChain()来处理，下面就来看看这个函数到底都做了些什么
@Throws(IOException::class)
internal 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)
//链接拦截器，dns解析，socket链接，tls链接，代理处理等
interceptors += ConnectInterceptor
if (!forWebSocket) {
//自定义网络拦截器
interceptors += client.networkInterceptors
}
interceptors += CallServerInterceptor(forWebSocket)
//创建一个RealInterceptorChain，把所有拦截器传入，算是拦截器处理的入口
val chain = RealInterceptorChain(
call = this, // 方便在拦截器中，获取当前的RealCall对象，因为有些操作是在RealCall对象里面的
interceptors = interceptors, //传入拦截器集合
index = 0, //默认从第一个拦截器开始，随着程序的运行，RealInterceptorChain中的这个变量会增加
exchange = null,
request = originalRequest,//网络请求，
//以下是超时时间设置
connectTimeoutMillis = client.connectTimeoutMillis,
readTimeoutMillis = client.readTimeoutMillis,
writeTimeoutMillis = client.writeTimeoutMillis
)
var calledNoMoreExchanges = false
try {
//开始执行 拦截器
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)
}
}
}
拦截器处理的核心，
1、这些拦截器需要按照顺序来依次执行，所以所有的拦截器必须有统一的接口，这样不管是什么拦截器，调用的方式都是一致的。（依赖倒置原则） 所有的拦截器都实现了Interceptor接口
2、 如何依次调用每个拦截器，其实 每个拦截器对应一个 RealInterceptorChain，拦截器在集合中的索引值 = RealInterceptorChain中的index，在调用拦截器 时，把RealInterceptorChain 对象next 传入，interceptor.intercept(next) 这样就可以在当前拦截器的任意位置，调用下一个拦截器了。
有同学可能有疑问，直接一个循环，遍历每个拦截器，调用每个Interceptor接口，这样不行吗？
这样没办法实现，在当前拦截器的任意位置调用下一个拦截器，每个拦截器的处理逻辑不一样，调用下一个拦截器的时机也不同
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
// 创建一个RealInterceptorChain 对象，为了调用下一个拦截器 （集合中index对应的拦截器）
internal fun copy(
index: Int = this.index,
exchange: Exchange? = this.exchange,
request: Request = this.request,
connectTimeoutMillis: Int = this.connectTimeoutMillis,
readTimeoutMillis: Int = this.readTimeoutMillis,
writeTimeoutMillis: Int = this.writeTimeoutMillis
) = RealInterceptorChain(call, interceptors, index, exchange, request, connectTimeoutMillis,
readTimeoutMillis, writeTimeoutMillis)
...省略代码...
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"
}
}
// Call the next interceptor in the chain.
//指定下一个拦截器的索引值，也就是当前拦截器索引值+1
val next = copy(index = index + 1, request = request)
//获取当前的拦截器
val interceptor = interceptors[index]
@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
}
}
在代码中，可以通过 addInterceptor() 和 addNetworkdInterceptor() 来添加自己的拦截器，分别叫做应用拦截器和网络拦截器，他们的调用时机如下图：
在getResponseWithInterceptorChain源码中可以看到，
也就是说应用拦截器是最先被调用的，网络拦截器是在网络链接后才被调用，如果发生地址重定向，网络连接器会被多次调用
自定义拦截器的使用、区别、示例代码，可以查看这篇文章Interceptors拦截器——OkHttp3详细使用教程
OkHttp的大概流程，就算是清楚了，接下来，就是针对每个拦截器的分析了。掌握了架构，再去补充细节，就容易掌握一些
本文地址：https://blog.csdn.net/xx326664162/article/details/107183019
如对本文有疑问， 点击进行留言回复！！
网友评论