OkHttp简析及实现

OkHttp简析及实现

还记得 2015 年刚开始学习 Android 那会，还在为 Eclipse 项目中集成 Afinal.jar 、 Volley.jar 爆红而发愁，一晃而过到现在的 2020 年，见证了 AndroidStudio 的兴起。就这短短的5年时间，很多工具和技术都进行了更新换代或者在升级

今天我们就看看经过官方承认并使用的网络请求框架 OkHttp。

OkHttp简析

使用

接入 OkHttp

先来康康怎么接入，直接 gradle 中一行代码就搞定了。确实比之前还要下载相关 jar 包，然后在复制粘贴，然后在添加相关配置要简单的多了

implementation 'com.squareup.okhttp3:okhttp:4.8.1'

如果一行代码搞不定的话，那就再加几行 - -~，在项目的 build 文件中添加国内镜像

buildscript {
    repositories {
        maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
        maven { url "https://dl.bintray.com/thelasterstar/maven/" }
    }
}
allprojects {
    repositories {
        maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
        maven { url "https://dl.bintray.com/thelasterstar/maven/" }
    }
}

调用

调用就比较简单了，构建请求端，发送请求，回调接受请求结果。

//创建请求端
OkHttpClient()
        //创建请求体
        .newCall(Request.Builder().url("https://www.baidu.com").build())
        //创建请求完成后的回调接口
        .enqueue(object :Callback{
            override fun onFailure(call: Call, e: IOException) {
                
            }

            override fun onResponse(call: Call, response: Response) {
                
            }
        })

使用方面无甚可说，主要就是在项目中应用的时候，尽量在 okhttp 之上在包装一层。这样如果后期需要更换底层 okhttp 的时候对于项目改动就比较小了。

下面就从源码简单分析一下 okhttp 的实现

源码简析

注意看题目，是源码简析，如果你想看完这篇文章就可以搞清楚 okhttp 的源码，那就要大失所望了。不是咱家不想写呀，主要是源码里面的细节处理和架构的设计，用文字表达就没有那个感觉了，还是得去撸源码，所以这里就只是把整个流程梳理一遍，具体的细枝末节都没有去说明。比如：建造者模式、责任链模式、线程池、线程安全等，在源码中都可以找到相应的影子。

闲话不多说，先来一张简易的调用流程图

从上面的调用流程图逐步分析源码，看看涉及到的类的相关调用

/**
 *  OkHttpClients Should Be Shared
 * 意思就是 OkHttpClient 这个玩意在应用中创建一次就可以进行全局共享了，没有比较多次创建。
 * 所以我们上面那个写法有点不规范哈，别纠结
 */
open class OkHttpClient internal constructor(
  builder: Builder
) : Cloneable, Call.Factory, WebSocket.Factory {
    //① 构造一个 OkHttpClient 请求端
    //这里的 builder 用到了建造者模式。里面主要是一些配置相关信息，感兴趣可以撸源码，这里不多说
    constructor() : this(Builder())

    /** Prepares the [request] to be executed at some point in the future. */
    //通过传进来的 request 请求体，构造一个真正的请求结构 RealCall ，将来便于添加到线程池中运行
    //② 调用 newCall 方法构造一个真正的请求体
    override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)
}

class RealCall(
  val client: OkHttpClient,
  /** The application's original request unadulterated by redirects or auth headers. */
  val originalRequest: Request,
  val forWebSocket: Boolean
) : Call {
  // ③ 调用该方法将异步请求 AsyncCall 加入线程池执行
  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()
    client.dispatcher.enqueue(AsyncCall(responseCallback))
  }
  internal inner class AsyncCall(
    private val responseCallback: Callback
  ) : Runnable {
    
    override fun run() {
      threadName("OkHttp ${redactedUrl()}") {
        var signalledCallback = false
        timeout.enter()
        try {
          // ④ 线程执行 run 方法请求网络返回结果 response
          val response = getResponseWithInterceptorChain()
          signalledCallback = true
          // ⑤ 回调正确结果
          responseCallback.onResponse(this@RealCall, response)
        } catch (e: IOException) {
          if (signalledCallback) {
            // Do not signal the callback twice!
            Platform.get().log("Callback failure for ${toLoggableString()}", Platform.INFO, e)
          } else {
            // ⑤ 回调失败结果
            responseCallback.onFailure(this@RealCall, e)
          }
        } catch (t: Throwable) {
          cancel()
          if (!signalledCallback) {
            val canceledException = IOException("canceled due to $t")
            canceledException.addSuppressed(t)
            // ⑤ 回调取消结果
            responseCallback.onFailure(this@RealCall, canceledException)
          }
          throw t
        } finally {
          client.dispatcher.finished(this)
        }
      }
    }
  }
}

好了，okhttp 的调用流程这里就结束了，够简单吧，不过这是真的啊，就是这么个流程，剔除了一下繁杂的判断和细节处理。

当然，上面那个没有说到 okhttp 的精髓所在，就是步骤 ④ 中的 getResponseWithInterceptorChain 这个方法，下面我们进去看看。

class RealCall(val client: OkHttpClient, val originalRequest: Request, 
    val forWebSocket: Boolean) : Call {
  @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)
    // connect 请求拦截器
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      //网络拦截器 
      interceptors += client.networkInterceptors
    }
    // 调用服务拦截器
    interceptors += CallServerInterceptor(forWebSocket)

    // 创建一个真正的拦截链条，并且将当前的拦截器集合传递进去
    val chain = RealInterceptorChain(
        call = this,interceptors = interceptors,index = 0,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)
      }
    }
  }
}

/**
 * A concrete interceptor chain that carries the entire interceptor chain: all application
 * interceptors, the OkHttp core, all network interceptors, and finally the network caller.
 *
 * 一个具体的拦截器链，包含整个拦截器链：所有应用程序*拦截器，OkHttp核心，所有网络拦截器，最后是网络调用者。
 */
class RealInterceptorChain(...){
  @Throws(IOException::class)
  override fun proceed(request: Request): Response {
    ......

    calls++

    ......

    // Call the next interceptor in the chain.
    // 获取下一个拦截器
    val next = copy(index = index + 1, request = request)
    // 当前的拦截器
    val interceptor = interceptors[index]

    // 调用当前拦截器的 intercept 方法处理相关逻辑，并且将下一个拦截器传入，执行完成后返回 response
    @Suppress("USELESS_ELVIS")
    val response = interceptor.intercept(next) ?: throw NullPointerException(
        "interceptor $interceptor returned null")

    ......
    return response
  }
}

上面就是 okhttp 的核心所在了，将一个网络请求的各个逻辑拆分成一个个拦截器去处理，比如重试机制、缓存机制、网络连接等。下面来一张图可能就比较直观了，依据整个责任链条，逐步处理自己相应的逻辑，并最终依据链条，将结果逐步返回。

简易版OkHttp

下面是根据上面的逻辑，实现了一个大致的流程，是相当的粗糙。我觉得通过 150 行代码能梳理清除相关逻辑就可以了，不喜请喷

package com.silence.okhttpdemo.ok

import java.lang.Exception
import java.util.concurrent.SynchronousQueue
import java.util.concurrent.ThreadFactory
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit


/**
 * Author silence.
 * Time：2020/8/19.
 * Desc：简易版 okHttp，只为说明其大致流程
 */
object OK {
    private val okHttp = OkHttp()

    fun newCall(request: Request) = RealCall(okHttp,request)

    fun addInterceptor(interceptor: Interceptor){
        okHttp.interceptors.add(interceptor)
    }
}
class Request(val url:String,var header:String = "")

class Response{
    var isCache = false
    var url=""
    var header = ""
    var body = ""
    var result = ""
}

interface Callback {
    fun onResponse(response: Response)
}

class Dispatcher{
    private val executorService = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS,
        SynchronousQueue(), ThreadFactory { runnable ->
            Thread(runnable, "customer Thread")
        }
    )
    internal fun enqueue(call: RealCall.AsyncCall) {
        executorService.execute(call)
    }
}

class OkHttp {
    val dispatcher = Dispatcher()
    val cacheMgr = CacheMgr()
    val interceptors = mutableListOf<Interceptor>()
}

class RealCall(private val okHttp: OkHttp,
               private val request: Request){

    fun enqueue(responseCallback: Callback){
        okHttp.dispatcher.enqueue(AsyncCall(responseCallback))
    }

    fun enqueue() = getResponseWithInterceptorChain()

    internal fun getResponseWithInterceptorChain(): Response {
        val interceptors = mutableListOf<Interceptor>()
        interceptors += okHttp.interceptors
        interceptors += RetryAndFollowUpInterceptor()
        interceptors += CacheInterceptor(okHttp.cacheMgr)
        interceptors += CallServerInterceptor()
        val chain = RealInterceptorChain(interceptors,0,request)
        return chain.proceed(request)
    }

    internal inner class AsyncCall(private val responseCallback: Callback) :Runnable{
        override fun run() {
            responseCallback.onResponse(getResponseWithInterceptorChain())
        }
    }
}
interface Interceptor {
    fun intercept(chain: Chain): Response
    interface Chain {
        fun proceed(request: Request): Response
        fun request():Request
    }
}

class RealInterceptorChain(
    private val interceptors: List<Interceptor>,
    private val index: Int,
    private val request: Request
) : Interceptor.Chain{

    override fun proceed(request: Request): Response {
        val next = RealInterceptorChain(interceptors,index+1,request)
        val interceptor = interceptors[index]
        return interceptor.intercept(next)
    }

    override fun request() = request

}
class RetryAndFollowUpInterceptor : Interceptor{
    var retryCount = 0
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        while (true){
            try {
                return chain.proceed(request)
            } catch (e:Exception){
                retryCount++
            }
            if (retryCount > 3){
                val response = Response()
                response.result = "error"
                response.url = chain.request().url
                return response
            }
        }
    }
}
class CacheMgr{
    //这里肯定不能这么写昂，我这么写只是为了便于理解
    val cache = hashMapOf<String,Response>()
}
class CacheInterceptor(private val cacheMgr: CacheMgr) : Interceptor{

    override fun intercept(chain: Interceptor.Chain): Response {
        var response = cacheMgr.cache[chain.request().url]
        if (response == null){
            response = chain.proceed(chain.request())
            cacheMgr.cache[chain.request().url] = response
        } else {
            response.isCache = true
        }
        return response
    }
}
class CallServerInterceptor : Interceptor{
    //注意这里，作为最后一个 Interceptor，这里没有在调用 chain.proceed 方法了
    // 所以这里就是最底部了，从这里开始逐级向上返回 response
    override fun intercept(chain: Interceptor.Chain): Response {
        val response = Response()
        response.body = "body"
        response.header = chain.request().header
        response.result = "ok"
        response.url = chain.request().url
        return response
    }
}

在来康康怎么调用，基本上和 okHttp 调用方式差不多

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        OK.addInterceptor(object :Interceptor{
            override fun intercept(chain: Interceptor.Chain): Response {
                val request = chain.request()
                request.header = "customer header"
                return chain.proceed(request)
            }
        })

       OkHttpClient()
               .newCall(
                       Request.Builder()
                               .url("https://www.baidu.com")
                               .build()
               ).enqueue(
                       object : Callback {
                           override fun onFailure(call: Call, e: IOException) {

                           }
                           @Throws(IOException::class)
                           override fun onResponse(call: Call, response: Response) {
                           }
                       }
               )
    }

    fun asnyc(view: View) {
        OK.newCall(Request("https://www.baidu.com"))
            .enqueue(object :Callback{
                override fun onResponse(response: Response) {
                    Log.d("silence","url:${response.url} , result:${response.result} , header:${response.header} , isCache:${response.isCache} , body:${response.body}")
                }
            })
    }
    fun Synchronize(view: View) {
        thread {
            val response = OK.newCall(Request("https://www.baidu.com")).enqueue()
            Log.d("silence","url:${response.url} , result:${response.result} , header:${response.header} , isCache:${response.isCache} , body:${response.body}")
        }
    }
}

ok，到这基本上就大致理清整体思路了，上面没有说到的任何一个细枝末节都足以用一篇文章详细描述，太多了，还是自己去扒拉吧，read the fuck code，best wishes