框架和流程——OkHttp 源码详解(一)

前言

框架和流程——OkHttp 源码详解(一)
ConnectInterceptor 解析——OkHttp 源码详解(二)

OkHttp应该是目前Android平台上使用最为广泛的开源网络库了,Android 在6.0之后也将内部的HttpUrlConnection的默认实现替换成了OkHttp。

网上很多分析OkHttp的,都是在总体流程上,没有那么的细致,甚至有的同学看完了文章,认为OkHttp没有DNS解析。所以本系列会深入源码,既掌握结构,也了解细节

一、鸟瞰OkHttp

下面的代码是一个很简单的例子,一步一步分析,起内部的工作原理

 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核心——拦截器

二、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,在调用拦截器 时,把 next(RealInterceptorChain对象)传入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
  }
}

看到这里你可能还不清楚,这些拦截器到底是如何依次被触发的,在分析 ConnectInterceptor拦截器的文章 中,你可以更清楚的看到,下一个拦截器的触发

三、 关于自定义拦截器

在代码中,可以通过 addInterceptor() 和 addNetworkdInterceptor() 来添加自己的拦截器,分别叫做应用拦截器和网络拦截器,他们的调用时机如下图:

在这里插入图片描述

getResponseWithInterceptorChain源码中可以看到,

  • 应用拦截器 interceptors 是最先被加入集合的,
  • 网络拦截器networkInterceptors 是在ConnectInterceptor 之后被添加的,

也就是说应用拦截器是最先被调用的,网络拦截器是在网络链接后才被调用,如果发生地址重定向,网络连接器会被多次调用

自定义拦截器的使用、区别、示例代码,可以查看这篇文章Interceptors拦截器——OkHttp3详细使用教程

结语

OkHttp的大概流程,就算是清楚了,接下来,就是针对每个拦截器的分析了。掌握了架构,再去补充细节,就容易掌握一些

©️2020 CSDN 皮肤主题: 撸撸猫 设计师:设计师小姐姐 返回首页