24.责任链模式(大话设计模式kotlin版)

责任链模式

定义

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

UML图

24.责任链模式(大话设计模式kotlin版)_第1张图片

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}请求

责任链的优缺点

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

你可能感兴趣的:(设计模式,设计模式)