设计模式:责任链模式+思维导图+uml

责任链模式思维导图简介

设计模式:责任链模式+思维导图+uml_第1张图片

结构组成详解

  1. 抽象处理者、具体处理者、客户端关系UML图
    设计模式:责任链模式+思维导图+uml_第2张图片
  2. 客户端拼装组成的责任链
    设计模式:责任链模式+思维导图+uml_第3张图片

抽象处理者

设计模式:责任链模式+思维导图+uml_第4张图片

abstract class AbsDispatchHandle {
	// 具体处理者标识
    var handleLevel_1: Int = 1
    var handleLevel_2: Int = 2
    var handleLevel_3: Int = 3


    /**
     * @param nextDispatchHandle 接收持有的下一个DispatchHandle
     * */
    var nextDHandle: AbsDispatchHandle? = null

    /**
     * 1.用于初始化时调用handleDispatchRequest发送消息
     * 2.处理消息是处理还是继续分发
     * @param request 发送的消息对象 ,消息的分发
     *
     * */
    fun handleDispatchRequest(request: AbsDispatchRequest) {
        if (request.getDispatchRequestLevel() == getHandleRequestLevel()) {
        // 判断 这个请求消息设置的具体处理者标识和当前处理者对象的标识是否相等  相等就直接处理
            toHandleDispatchRequest(request)
        } else {
       //否则,继续传递
            nextDHandle?.handleDispatchRequest(request)
        }
    }

    /**
     * 由子类重写,具体处理消息对象
     * @param request 要处理的request对象
     * */
    abstract fun toHandleDispatchRequest(request: AbsDispatchRequest)

    /**
     * 根据级别去处理请求
     * */
    abstract fun getHandleRequestLevel(): Int
}

具体处理者

需要继承抽象处理者(AbsDispatchHandle),重写处理消息的方法(toHandleDispatchRequest)
另外两个具体处理者不在贴出代码,一样的。

class ChildDispatchHandle_1 : AbsDispatchHandle() {
    override fun getHandleRequestLevel(): Int {
        return handleLevel_1
    }

    override fun toHandleDispatchRequest(request: AbsDispatchRequest) {
        System.out.println("${request.requestMSG("ChildDispatchHandle_1 ")} ")
    }
}

抽象处理者和具体处理者的关系:

设计模式:责任链模式+思维导图+uml_第5张图片

客户端

主要作用:拼接组成,形成链式

调用:
设计模式:责任链模式+思维导图+uml_第6张图片

        AbsDispatchHandle childDispatchHandle_1 = new ChildDispatchHandle_1();
        AbsDispatchHandle childDispatchHandle_2 = new ChildDispatchHandle_2();
        AbsDispatchHandle childDispatchHandle_3 = new ChildDispatchHandle_3();

        childDispatchHandle_1.setNextDHandle(childDispatchHandle_2);// 持有下一个处理者
        childDispatchHandle_2.setNextDHandle(childDispatchHandle_3);// 持有下一个处理者

        AbsDispatchRequest request = new Request();
        ((Request) request).setDispatchRequestLevel(1);// 控制由那个处理者来处理消息

        childDispatchHandle_1.handleDispatchRequest(request);

AbsDispatchRequest(消息对象)


abstract class AbsDispatchRequest {
    abstract fun getDispatchRequestLevel(): Int

    fun requestMSG(msg: String): String {
        return "AbsDispatchHandle = ${msg}"
    }
}

Request

class Request : AbsDispatchRequest() {

    var requestFlag: Int = 0
    override fun getDispatchRequestLevel(): Int {
        return requestFlag
    }

    fun setDispatchRequestLevel(requestFlag:Int){
        this.requestFlag=requestFlag
    }

}

应用场景

具体的使用场景:

  1. 多个对象可以处理请求
  2. 可动态指定 或 不指定一个对象处理请求,或添加新的处理对象

关于设计模式

个人认为设计模式没有一个标准的写法,关键在于你怎么去融汇贯通。

责任链模式也分种类:

  1. 纯责任链模式:一个请求必须被某一个处理者对象所接收。对于具体处理者,要么自己处理要么下发给下一个具体处理者
  2. 不纯责任链模式:一个请求被一个处理者处理了一部分,将剩下的交给下一个具体处理者。例如有序广播
  3. 设计模式的变种:touch事件分发

扩展

例如:老师批阅学生卷子,他可以自己批阅完,也可以自己批一部分,剩下的交给另外一位老师。

改造之前的例子:
在第一个老师(具体处理者):拿到卷子后自己处理一部分,剩下部分可以指派给具体的处理者去处理。

class ChildDispatchHandle_1 : AbsDispatchHandle() {
    override fun getHandleRequestLevel(): Int {
        return handleLevel_1
    }

    override fun toHandleDispatchRequest(request: AbsDispatchRequest) {
   //这log表示处理 一部分  
     System.out.println("${request.requestMSG("ChildDispatchHandle_1 ")} ")
	// 继续下发给下一个处理者
        var newRequest=NewRequest()
        newRequest.setDispatchRequestLevel(3)
        nextDHandle!!.handleDispatchRequest(newRequest)
    }
}

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