24.责任链模式（大话设计模式kotlin版）

责任链模式

定义

责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送和接收者直接的过渡耦合。思想：将处理对象串成一条链，请求沿着这条链进行传递，直到有一个对象处理它为止。

UML图

Hanlder：处理者的抽象类，它提供为该处理者设置下一个处理者，或者之间处理该请求；

基本代码实现

Hanlder类

/**
 * @create on 2020/8/23 13:45
 * @description Hanlder 处理者类
 * @author mrdonkey
 */
abstract class Handler {

    protected var mSuccessor: Handler? = null

    /**
     * 设置继承者
     */
    fun setSuccessor(successor: Handler): Handler {
        this.mSuccessor = successor
        return this
    }

    /**
     * 处理请求的方法
     */
    abstract fun handlerRequest(requestCode: Int)
}

ConcreteHandler1：处理者1

/**
 * @create on 2020/8/23 13:48
 * @description 处理者1
 * @author mrdonkey
 */
class ConcreteHandler1 : Handler() {

    override fun handlerRequest(requestCode: Int) {
        when (requestCode) {
            in 0 until 10 -> println("${this::class.java.simpleName}可处理的{$requestCode}请求")//0-9
            else -> {
                println("${this::class.java.simpleName}无法处理的{$requestCode}请求，交给上级")
                mSuccessor?.handlerRequest(requestCode)
            }
        }
    }
}

ConcreteHandler2：处理者2

/**
 * @create on 2020/8/23 13:48
 * @description 处理者2
 * @author mrdonkey
 */
class ConcreteHandler2 : Handler() {

    override fun handlerRequest(requestCode: Int) {
        when (requestCode) {
            in 10 until 20 -> println("${this::class.java.simpleName}可处理的{$requestCode}请求")//10-19
            else -> {
                println("${this::class.java.simpleName}无法处理的{$requestCode}请求，交给上级")
                mSuccessor?.handlerRequest(requestCode)
            }
        }
    }
}

ConcreteHandler3：最终处理者，如果下级无法处理必须进行处理

/**
 * @create on 2020/8/23 13:48
 * @description 处理者3:最初处理者，必须处理
 * @author mrdonkey
 */
class ConcreteHandler3 : Handler() {

    override fun handlerRequest(requestCode: Int) {
        println("${this::class.java.simpleName}是boss处理{$requestCode}请求")
    }
}

Client：客户端

/**
 * @create on 2020/8/23 13:54
 * @description 客户端
 * @author mrdonkey
 */
class Client {
    companion object {
        @JvmStatic
        fun main(vararg string: String) {
            val handler1 = ConcreteHandler1()
            val handler2 = ConcreteHandler2()
            val handler3 = ConcreteHandler3()
            //设置继承者（上级）
            handler1.setSuccessor(handler2)
            handler2.setSuccessor(handler3)
            //构建一个请求数组并开始进行请求
            for (requestCode in 0..20 step 5)
                handler1.handlerRequest(requestCode)
        }
    }
}

输出

ConcreteHandler1可处理的{0}请求
ConcreteHandler1可处理的{5}请求
ConcreteHandler1无法处理的{10}请求，交给上级
ConcreteHandler2可处理的{10}请求
ConcreteHandler1无法处理的{15}请求，交给上级
ConcreteHandler2可处理的{15}请求
ConcreteHandler1无法处理的{20}请求，交给上级
ConcreteHandler2无法处理的{20}请求，交给上级
ConcreteHandler3是boss处理{20}请求

责任链的优缺点

• 优点
  • 当客户传递一个请求时，请求时沿链传递直至有处理者对象进行处理；请求方不用知道最终的处理者是谁，处理者仅需要保持一个指向其后继者（上级处理者）的引用进行请求传递，从而降低请求者与接收者对象之间的耦合度。
  • 客户端可以随时随地的增加或修改一个请求的结构，增强了给对象指派职责的灵活性。
• 不足
  • 一个请求极有可能到了链的末端都得不到处理，或者因为没有正确的配置而得不到处理，需全面考虑请求的处理关系。