简述
责任链模式是一种对象的行为模式。通过建立一条链来组织请求的处理者，请求将沿着链进行传递，请求发送者无须知道请求在何时、何处以及如何被处理，实现了请求发送者与处理者的解耦。
如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<Interceptor> 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<String>) {
// 引用链
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
image
fun main(args: Array<String>) {
val chain = GroupLeader orElse DepartmentLeader orElse CTO
chain(FlowEvent("xxxxx",113))
}
/**
* 责任链模式中各环节对于输入的校验已经处理逻辑的问题。
*
* 协变- 泛型对象作为函数的参数，逆变- 泛型作为内部方法的返回。
*
* @param check 校验函数
* @param handle 处理函数
*/
class ChainFunction<in P1, out R>(
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 <P1, R> ChainFunction<P1, R>.orElse(function: ChainFunction<P1, R>): ChainFunction<P1, R> {
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核心编程》
