前文

信任咱们对Okhttp的职责链办法应该现已很熟悉了，今天给咱们遍及其他一种有意思的玩法。

先把场景给咱们描绘下，省的各位大佬说我过度规划代码。我就以我写的谷歌付出作为比如吧。谷歌付出对大部分调用场景都是选用async异步接口回调的办法进行封装的。

  1. 与谷歌payokhttp面试建立链接，假定链接失利，进行java面试题三次重试之后仍是失利则结束。
  2. 查询是不是又okhttp是干什么用的没有验后端开发薪酬一般多少证的订单，假定有则处理，假定没有则向下实施。
  3. 查询Sku数据，假定失利则结束，成功之后持续逻辑实施。
  4. 依据Sku数据进行付出，之后异步获取支开源是什么意思付作用，然后依据回来值判别是否向下实开源是什么意思行。
  5. 调用Api奉告后端买卖作用，假java怎样读设失利进行重试，假定仍是失利则间断，成功持续向下实施。
  6. 判别订单是不是有库存商品，假定是则调用核销Api，没有则持续向下。
  7. 判别订单是不是订阅，假定是订阅则需求调用确认api，依据异步作用毕竟结束整条付出流程。

这个时分你们要说了，这不便是厌烦一点点罢了后端吗，我上我也行啊。一般会有这么几种大佬处理办法。

  • 异步大佬，异步套异后端步套异步，一把梭哈便是干，了不起便是7层嵌套吗。

  • 同步大佬，道理上来说万物可javascript同步化，我只需子线程while trokhttp使用ue去等候取值，就能够把全部的异步都转化成同步。

  • RxJava或许协程大佬，这不便是个简略的链式操作，每个链每个function只担任做他们相关的操作后端开发需求把握什么技能，便是异步转化成Rxjava或许厌烦了一点点，可是问题并不大。

抛出一个问题，RxJjavascriptava是怎样结束次序链式实施的？ 有没有觉得和OkHttp的职责链有点相似呢？ 马萨卡！

一个比如了解Rxjava的工作开源矿工流转化原理 , 有喜好的同学能够看下这篇文章的后端和前端有什么差异分析。

正文

咱们这次的解决方案便是选用职责链的办法对这有实施次序的代码进行一次改造。这儿我首先要感谢下wmrouter的作者，某微软大佬，大佬的代码给了我很好的启示，也便是从wmrouter中我根柢把握了这种好玩的规划办法。

Demo的话咱们能够参看下我早年写的路由项目，也是依据这种异步职责链后端言语开发的。

路由Demo项目后端工程师链接

职责链介绍

职责链办法是后端工程师一种规划办法。在职责链办法里，许多政策由每一个政策对其下家的引证而联接起来构成一条链线程池创立的四种。央求在这个链上传递，直到链上的某一个政策抉择处理此央求。宣布这个央求的客户端并不知道链上的哪一个政策毕竟处理这个央求，这使得体系能够在不影响客户端的状况下动态地从头组okhttp面试答复织和分配职责。(参看百度百科)

我偷了两张网图介绍okhttp的职责链后端言语的，相对来说仍是比较形象的。

活学活用职责链 | 射鸡形式

全体拦截器的流程如下图所示。

活学活用职责链 | 射鸡形式

简线程和进程的差异是什么略的说，职责链java言语便是依照特定的次序向下实施的一个进程。咱们了解最多的应该是okhttp的职责链。咱们先从这个讲起，比较两部分差异。

fun interfa线程是什么意思ce Interceptor {
@Throws(IOException::class)
fu开源是什么意思n inokhttp使用过程tercept(chain: Chain): Response
interface Chain {
fun request(): Request
@Throws(IOExcOKHttpeption::class)
fun proceed(request: Request): Response
}
}

OkHjava游戏ttp的职责链是线程池由一个Interceptor和一个Chain的接口初步的。然后经过这个Chain的proceed办法实施下一个拦开源矿工截器内的代码。由于proceed办法由于有回来值，全部有必要确保下一个拦截器中有回来值才行。这便是说p开源矿工roceeokhttp封装d办法有必要线程要是一个同步的办法(当场有回来值的办法)。

无回来值的职责链

这okhttp源码解析个时分开源矿工你说了，那开源阅览app下载安装么已然要求了下一个职责链必定要有回来，那么还咋结束异步职责链啊？这部分仍是用之前路由项目来介绍吧，毕竟谷歌付出是公司代码(我被开除了你们养我？？？)， 不是特别便利开源。

inteokhttp使用过程rface Interceptor {
@Throws(RouteNotFoundException::class)
fun intercept(cokhttp面试hain: Chain)
interface Chain {
val url: KReque开源众包st
val context: Context
@Throws(RouteNotFoundException::cl后端开发薪酬一般多少ass)
fun proceed()
}
}

对比观察下，其实两个职责链最大的不同便是intjava根底知识点ercept办法有没有具体的回来值。而proceed则只担任奉告当时拦截器是否向下实施了。简略的说两种职责链办法最大的差异就在这个当地了。

class LogInte线程安全rc开源我国eptor : Interceptor {
override fun intercept(chain: Interceptor.Chai后端工程师n) {
Log.i("LogInterceptor", "LogInterceptor")
ch开源矿工ain.proceed()
}
}

正常状况下，咱们的拦截器逻辑会和上面的代码相同，可是由于其实当时办法是没有回来值的，也便是说咱们的一个异步任务只需持有了chain的实例，那么当咱们的异步有作用回调了之后，再实施咱们的pro线程撕裂者c后端开发和前端开发的差异eed办法持续实施下一个链式调用是线程安全不是就能够了。下面咱们上一个异步的结束看看。

cokhttp是干什么用的lass DelayInterceptor : Interceptor {
override fun intercept(chain: I线程安全nterceokhttp是干什么用的ptor.Chain) {
GlobalScope.launch {
// 建立谷歌链接
delay(5000)
withContext(Dispatchers.Main) {
chain.procee后端工程师d()
}
}
}
}

我在这个拦截器中运用了协程的推迟，delay代表运用了一个前文中提建立谷歌链接，然后咱们调度到了主线程中之后调用职责链的下一个。由于fun是没有回来值的，而咱们持有了chain的引证，所以咱们能够在开源矿工恣意的异步中调用职责链的下一线程池原理个，这样就结束了一个可异步的职责链封装了。

结束Chaijava面试题n

以我的路由的职责链为比如，其实pr线程的几种状态oceed办法是十分简略粗犷的，经过index+1的办法调用下下一个拦截器，然后实施他java面试题的代码就行了，假定list为空则回来。

class RealInterceptjava根底知识点orChain i后端破解体系nternal constructor(private val interceptors: List<Interceptor>, override val url: KRequest,
override val hostParams: Mjava模拟器ap<String, HostParams>?,
pri线程和进程的差异是什么vate val index: Int, override
val context: Context)开源阅览 : Interceptor.Chain {
@Throws(RouteNotFoundException::class)
override fun proceokhttp封装ed() {
proceed(url)
}
@Throws(Rou线程池创立的四种teNotFoundException::class)
fun proceed(request: KReque后端开发需求把握什么技能st) {
if (index >= intokhttp面试erceptors.size) {
r开源我国eturn
}
val next = RealInterceptorChain(interceptors, request, hostParams,
index + 1, context)
val interceptor = intejava编译器rceptors[index]
interceptor.intercept(next)
}
}

其他一个则是需求有一个当地专门去把整个链Java式调用的拦截器放在一个列表内，对外运用的则是这个Call类。

class RealCall(pri开源代码网站githubvate vajava根底知识点l hostMap: Map<String, HostParams>, pri线程池vate val config: Route开源我国Configuration) {
private v线程池面试题al cachedRoutes: HashMa线程池p<S开源节流tring, RouterParams> = hashMapOf()
@Throws(RouteNotFoundException::class)
fun open(request: KRequest, context: Context) {
getParamsWithInterceptorChain(request, context)
}
@Throws(Ro开源众包uteNotFoundExce后端开发薪酬一般多少p线程撕裂者tion::class)
private fun getParamsWithInterceptorChain(request: KRequest, context: Contejava面试题xt) {
val intokhttp面试答复erceptors: MutableList<开源矿工Interceptor&gtjavahdxx; = ArrayL线程撕裂者ist()
if (config.lazyInitializer) {
in后端开发terceptors.add(LazyInitInterceptor())
}
interceptors.a开源是什么意思ddAll(config.interceptors)
interceptors.add(CacheInterceptor(cachedRoutes))
interceptors.add(Routjava言语erIntercep后端开发tor(cachedRoutes))
val chain: Interceptor.Chain = RealInterceptorChain(interceptors, request, hostMap, 0, context)
chain.proceed()
}
}

RealCall经过这样一个List以及对外显露的open办法，咱们就能确保这个职责链的次序向下实施了。并且由于上面介绍到的Chain是经过proceed办法来奉告下一个链被实施的。全部整个链就会被串联起来了。

在谷歌Pay中，由于他们其实并不算是个拦截器，而是一个处理器，所以这部分被我界说成了Handler。每个Handler担任处理自己当时所需求的那部分逻辑，当他结束之后则交给下一个Handler持续实施。

这部分能够用伪代码给咱们介绍下。

联接Handler{
async线程池{
if(联接成功){
下一个Han后端和前端有什么差异dler
}else{
重连线程池面试题试试看 3次则都失利回来
}
}
}
谷歌掉单Handler{
async{
if(没有掉单){
下一个Handler
}else{
间断
}
}
}
其他handler
.Java..

我写了两个伪代码，代表了这部分Handler的处理逻辑，其他的都依照相似的去处理就行了。这样写的长处便是每一个由于每一个Handler只担任自己的逻辑，这样后续在晋级维护进程中就会相对来说比较简略，并且中心能够刺进一些其他处理器，或许okhttp长处调整次序便利代码复用等。

并且也能够避免呈现回调阴间的状况后端开发，假开源阅览app下载安装设代码只要成功回调就算了，假定还有失常则便是一坨稀泥了。说句最尖锐的假定我滚蛋了，后边的人只需依照职责链次序查看代码逻辑就能够简略的了解其结束了。

有或许呈现的后端开发需求把握什么技能问后端开发需求把握什么技能题

那么这种写法还有什么不足之处吗？

由于全部都是异步操作，而异步则意味着要持有后端开发需求把握什么技能引证，所以没有和LifeCycle绑定的情后端开发况下简略呈现内存泄露的状况。举个比如，页面毁掉了然后回调了作用，之后由于持有了回调，就会导致内存泄露的状况发生了。

这个时分咱们供给其他一后端工程师个间断的指令能够帮忙咱们优化泄露的状况。当当时职责链间断，则清空全部的Handler引证。

interface Chain {
val cont开源众包ext线程: Context
val lifec开源众包ycleOwner: LifecycleOwner?
fun proceed()
fun onComplete()
}

class RealCall:Handler.Chain,LifecycleObserver{
override fun onComplete() {
// 清空你的职责链列表
handlers.clear()
}
}

还有便是由于java言语全部都是异步的，所以会相对增加代码了解的难度，可是我个人觉得全体上来说仍java怎样读是要优于异步嵌套的。

一起由于办法并没有回来值，关于参数传递其实就并不是特别友好了，也只能经过异步的办法将作用传输给到运用方。尽管避免了许多的回调嵌套，可是仍是要给运用方一个回调给予毕竟的处理作用的。

假定应用于相似路由这种场景的话，其实灵活Java性我感觉是远远比有回来值的拦截器要好许多的。

总结

假定这部分代码能让我运用协程去写，我觉得我完全信手okhttp面试拈来，没有任何压力。可是由于是一个sdk方，所以在输出代码的状况开源阅览下要考虑到运用方有没有类库，并且线程最小依托粒度的乐意，所以只能采纳这种规划办法去让代码的依托降到更少，并且让后端开发代码后边的可维护性更高一点。

这部分代码我也不是一初步就想到的，我也是先手写撸了一遍，然后想了想，假定过一阵子让我从头来接这部分代码，我估计会想javascript死。所以就从头规划了下这部分代码的结束，多考虑活学活用，不需求生搬硬套。