设计模式 - 行为型 - 责任链模式学习

淡乄然

已于 2023-03-08 11:37:19 修改

阅读量251

点赞数

分类专栏：设计模式文章标签：设计模式责任链模式学习

于 2023-02-10 14:33:36 首次发布

本文链接：https://blog.csdn.net/hcwbr123/article/details/128966394

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

现象：

设计模式 - 行为型 - 责任链模式学习

实现：

介绍：一个请求在这种模式中，多个接收者处理，每个接收者都包含对下一个接收者的引用。
	 如果一个对象不能处理该请求，那么它会把请求传给下一个接收者，依此类推
适用：一个请求被多个接受者接受 但是每个接收者要求满足要求才处理 在处理消息的时候过滤

方法：

创建抽象的处理类

public abstract class AbstractHandle {
    /**
     * 判断接收者是否执行的条件
     */
    protected Integer flag;

    /**
     * 此接受者的下一个接收者
     */
    protected AbstractHandle nextHandle;

    /**
     * 设置下一个接受者
     */
    public void setNextHandle(AbstractHandle nextHandle) {
        this.nextHandle = nextHandle;
    }

    /**
     * 此接收者处理和下一个接受者调用
     *
     * @param flag
     * @param message
     */
    public void run(Integer flag, String message) {
        /**
         * 检查是否满足此接受者处理条件 满足则处理
         */
        if (this.flag.equals(flag)) {
            execute(message);
        }
        /**
         * 调用下一个接受者处理
         */
        if (nextHandle != null) {
            nextHandle.run(flag, message);
        }
    }

    /**
     * 抽象子类实现的真正处理方法
     *
     * @param message
     */
    protected abstract void execute(String message);

}

第一层接受者实现

public class FirstFloorHandle extends AbstractHandle {

    /**
     * 实例化第一层的时候 设置条件
     * @param flag
     */
    public FirstFloorHandle(Integer flag) {
        this.flag=flag;
    }

    @Override
    protected void execute(String message) {
        // 第一层接收者的实际处理
        System.out.println(message+"--第一层处理完成--");
    }

}

第二层接受者实现

public class SecondFloorHandle extends AbstractHandle {

    /**
     * 实例化第二层的时候 设置条件
     * @param flag
     */
    public SecondFloorHandle(Integer flag) {
        this.flag=flag;
    }

    @Override
    protected void execute(String message) {
        // 第一层接收者的实际处理
        System.out.println(message+"--第二层处理完成--");
    }
}

第三层接收者实现

public class ThirdFloorHandle extends AbstractHandle {

    /**
     * 实例化第三层的时候 设置条件
     * @param flag
     */
    public ThirdFloorHandle(Integer flag) {
        this.flag=flag;
    }

    @Override
    protected void execute(String message) {
        // 第三层接收者的实际处理
        System.out.println(message+"--第三层处理完成--");
    }
}

创建每层接受者设置接受者里面的下一层接受者

    /**
     * 创建接受者 设置接受者里面的下一层接受者
     * @return 第一层处理者
     */
    private static AbstractHandle getHandle(){
        // 分别建立接受者
        var firstFloorHandle = new FirstFloorHandle(1);
        var secondFloorHandle = new SecondFloorHandle(2);
        var thirdFloorHandle = new ThirdFloorHandle(3);

        // 给接受者设置下一层接受者
        firstFloorHandle.setNextHandle(secondFloorHandle);
        secondFloorHandle.setNextHandle(thirdFloorHandle);

        // 返回第一层接受者
        return firstFloorHandle;
    }

测试调用

    public static void main(String[] args) {
        // 获取执行者
        var handle = getHandle();
        // 调用执行者方法执行
        handle.run(3, "开始处理:");
    }

调用handle.run(1, “开始处理:”);

调用handle.run(2, “开始处理:”);

调用handle.run(3, “开始处理:”);
在这里插入图片描述

运用实例：

结合实际使用场景运用责任链
场景：某个接口接受前端参数处理要经过一步或者多步处理

一：建立执行数据模型和对象

1.建立责任链执行基础对象
在这里插入图片描述
2.建立责任链执行数据模型、在责任链中实际执行的模型、使用泛型控制执行的对象需要继承我们的基础对象

3.建立某链接中执行的实际对象

二：建立责任链接口与多层实现

1.建立责任链接口
在这里插入图片描述
2.建立第一层实际处理
3.建立第二层实际处理

在这里插入图片描述
4.建立第三层实际处理

三：建立责任链容器与责任链处理Service
1.建立责任链容器
在这里插入图片描述
2.建立责任链处理Service
使用map 是因为可通过key的类型设置多个责任链来执行
如果只有一个责任链可省去责任链容器对象 ProcessTemplate 直接将List 放ApplyService