Android设计模式-责任链

简述

责任链模式是一种对象的行为模式。通过建立一条链来组织请求的处理者，请求将沿着链进行传递，请求发送者无须知道请求在何时、何处以及如何被处理，实现了请求发送者与处理者的解耦。

如Android 中的事件传递，Activity->ViewGroup->View，当然也可以View->ViewGroup-> Activity ，android 中是U形事件传递

另外OKhttp的interceptors实现，OkHttp发送网络请求的一切核心功能，包括建立连接、发送请求、读取缓存等，都是通过interceptors来实现的。这些interceptors在运行的时候彼此协作，构成了一个责任链interceptor chain

Response getResponseWithInterceptorChain() throws IOException {    // Build a full stack of interceptors.    List interceptors = new ArrayList<>();    interceptors.addAll(client.interceptors());    interceptors.add(retryAndFollowUpInterceptor);    interceptors.add(new BridgeInterceptor(client.cookieJar()));    interceptors.add(new CacheInterceptor(client.internalCache()));    interceptors.add(new ConnectInterceptor(client));    if (!forWebSocket) {        interceptors.addAll(client.networkInterceptors());    }    interceptors.add(new CallServerInterceptor(forWebSocket));    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,            originalRequest, this, eventListener, client.connectTimeoutMillis(),            client.readTimeoutMillis(), client.writeTimeoutMillis());    return chain.proceed(originalRequest);}

在 OkHttp 中，命令对象就是 Request 对象，处理对象就是每一个 Interceptor 对象。每个 interceptor 对 request 进行一些步骤的处理，而将其余的工作交给下一个 interceptor。注意到，责任链中的处理对象如果可以全权处理命令对象，则不需要交给下一个处理对象。OkHttp 中的 CacheInterceptor 也是具有全权处理的能力。如果请求的结果已经缓存，则不需要再交给 ConnectInterceptor 等进行连接服务器、发送请求的处理，直接返回已缓存的 response 即可。

例如常见的流程审批(当然在企业级APP中由服务端处理)

fun main(args: Array) {    // 引用链    val cto = CTO(null)    val department = DepartmentLeader(cto)    val group = GroupLeader(department)    //    group.handleEvent(FlowEvent("filepath ", 113))}data class FlowEvent(val filePath: String, val fileID: Int)interface FlowHandler {    val next: FlowHandler?    fun handleEvent(event: FlowEvent)}class GroupLeader(override val next: FlowHandler?) : FlowHandler {    override fun handleEvent(event: FlowEvent) {        when (event.fileID) {            // 根据文件ID分配审批权限 处理            111 -> print("GroupLeader收到流程：${event.filePath}")            // 否则转发            else -> when (next) {                // 转发到下一级                is FlowHandler -> {                    println("GroupLeader:  此流程被转发了")                    next.handleEvent(event)                }                else -> println("GroupLeader:  此流程不能被处理")            }        }    }}class DepartmentLeader(override val next: FlowHandler?) : FlowHandler {    override fun handleEvent(event: FlowEvent) {        when (event.fileID) {            // 根据文件ID分配审批权限 处理            112 -> println("DepartmentLeader收到流程：${event.filePath}")            // 否则转发            else -> when (next) {                // 转发到下一级                is FlowHandler ->  {                    println("DepartmentLeader:  此流程被转发了")                    next.handleEvent(event)                }                else -> println("DepartmentLeader:  此流程不能被处理")            }        }    }}class CTO(override val next: FlowHandler?) : FlowHandler {    override fun handleEvent(event: FlowEvent) {        when (event.fileID) {            // 根据文件ID分配审批权限            113 -> println("CTO收到流程 ：${event.filePath}，正在处理")            else -> println("CTO:  此流程不能被处理")        }    }}

输出：

GroupLeader:  此流程被转发了DepartmentLeader:  此流程被转发了CTO收到流程文件：filepath

以上可以参见责任链的工作机理，整个链条的每个处理环节都有对其输入参数的校验，只有输入参数在责任链环节的有效接收范围之内，才能处理相关的逻辑

偏函数

偏函数是数学中的概念，指的是定义域X中可能存在某些值在值域Y中没有相对应的值。

一个多元函数传入了部分参数之后的得到的新的函数。
参数的固定一般使用默认参数+具名参数。如果需要固定的参数在中间，虽然说可以通过具名参数来解决，但是很尴尬，因为必须使用一大堆具名参数。g

Function参见这里

fun main(args: Array) {   val chain =  GroupLeader orElse  DepartmentLeader orElse CTO    chain(FlowEvent("xxxxx",113))}/** * 责任链模式中各环节对于输入的校验已经处理逻辑的问题。 * * 协变-  泛型对象作为函数的参数，逆变- 泛型作为内部方法的返回。 * * @param check 校验函数 * @param handle 处理函数 */class ChainFunction(        private val check: (P1) -> Boolean,        private val handle: (P1) -> R) : (P1) -> R {    // 进行有效性检验 传递参数p1    override fun invoke(p1: P1): R {        if (check(p1)) {            // 校验通过执行handle函数            return handle(p1)        } else {            // 检验不通过抛出异常   throw  IllegalArgumentException("事件: ($p1) 无法被处理 ")        }    }    fun isChecked(p1: P1) = check(p1)}// 利用中缀函数形成引用链infix fun  ChainFunction.orElse(function: ChainFunction): ChainFunction {    return ChainFunction({        this.isChecked(it) || function.isChecked(it)    }) {        when {            this.isChecked(it) -> this(it)            else -> function(it)        }    }}val GroupLeader = {    val event: (FlowEvent) -> Boolean = {        it.fileID == 111    }    val handler: (FlowEvent) -> Unit = {        print("GroupLeader已处理该流程：filePath  ${it.filePath}")    }    // 传递    ChainFunction(event,handler)}()val DepartmentLeader = {    val event: (FlowEvent) -> Boolean = {        it.fileID == 112    }    val handler: (FlowEvent) -> Unit = {        print("DepartmentLeader已处理该流程：filePath  ${it.filePath}")    }    // 传递    ChainFunction(event,handler)}()val CTO = {    val event: (FlowEvent) -> Boolean = {        it.fileID == 113    }    val handler: (FlowEvent) -> Unit = {        print("CTO已处理该流程：filePath  ${it.filePath}")    }    // 传递    ChainFunction(event,handler)}()

CTO已处理该流程：filePath  xxxxx

如果责任链过长，或者链上的事件传递需要判断处理时间太长的话会影响性能，尤其是递归循环。

参考：

funKTionale
《Kotlin核心编程》

简述

偏函数

更多相关文章

随机推荐