十六、行为型（责任链模式）

伯牙碎琴2024-10-25 22:31

责任链模式（Chain of Responsibility Pattern）

概念

责任链模式是一种行为型设计模式，它使多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

责任链模式的核心思想是把请求的处理责任从一个对象转移到多个对象上。通过设置链式处理机制，多个对象可以动态参与请求处理，同时提高系统的可扩展性。

应用场景

  1. 多处理器处理请求：当一个请求可能被多个对象处理时，可以采用责任链模式将这些处理对象串联起来，沿着链条传递请求，直到找到合适的处理者。

  2. 避免复杂条件判断 ：如果在处理某些请求时，需要使用大量的条件语句（if-else 或 switch-case），可以通过责任链模式将处理逻辑分散到不同的对象中，从而避免代码臃肿、难以维护。

  3. 日志过滤或权限控制：在日志记录或权限验证的场景中，不同的日志级别或权限控制可以使用责任链模式进行逐级处理。例如，日志系统可以根据不同的日志级别决定是否记录或输出日志信息。

  4. 审批流程：当一个请求需要经过多级审批时，责任链模式可以很好地实现逐级审批的机制。如果某一级不能处理，则传递给下一层。

注意点

  1. 请求必须能最终得到处理：责任链模式的链条中必须有一个对象能够处理请求，否则请求可能被丢失。

  2. 链条过长时可能影响性能：如果链条中包含的处理者对象很多，请求在链中传递的时间可能会较长，因此链的长度不宜过长。

  3. 容易出现不必要的调用：如果链条中的某些处理者不必要地调用了处理方法，可能会导致不必要的性能开销。

核心要素

  1. Handler（处理者接口/抽象类）：定义处理请求的接口，同时包含设置下一个处理者的方法。

  2. ConcreteHandler（具体处理者）：实现处理者接口的类，负责处理具体的请求，或者将请求传递给下一个处理者。

  3. Client（客户端）：向链条上的处理者提交请求，由处理者决定如何处理该请求。

Java代码完整示例

示例：银行审批系统的责任链模式实现

java 复制代码 
// 抽象处理者
abstract class Approver {
    protected Approver nextApprover;  // 下一个处理者

    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    // 处理请求的抽象方法
    public abstract void approveRequest(int amount);
}

// 具体处理者：经理
class Manager extends Approver {
    @Override
    public void approveRequest(int amount) {
        if (amount <= 1000) {
            System.out.println("Manager approved request of amount " + amount);
        } else if (nextApprover != null) {
            nextApprover.approveRequest(amount);  // 传递给下一个处理者
        }
    }
}

// 具体处理者：总监
class Director extends Approver {
    @Override
    public void approveRequest(int amount) {
        if (amount <= 5000) {
            System.out.println("Director approved request of amount " + amount);
        } else if (nextApprover != null) {
            nextApprover.approveRequest(amount);  // 传递给下一个处理者
        }
    }
}

// 具体处理者：CEO
class CEO extends Approver {
    @Override
    public void approveRequest(int amount) {
        if (amount > 5000) {
            System.out.println("CEO approved request of amount " + amount);
        } else if (nextApprover != null) {
            nextApprover.approveRequest(amount);
        }
    }
}

// 客户端代码
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Approver manager = new Manager();
        Approver director = new Director();
        Approver ceo = new CEO();

        // 设置责任链：经理 -> 总监 -> CEO
        manager.setNextApprover(director);
        director.setNextApprover(ceo);

        // 提交请求
        System.out.println("Requesting approval for amount 500:");
        manager.approveRequest(500);  // Manager handles this request

        System.out.println("\nRequesting approval for amount 3000:");
        manager.approveRequest(3000);  // Director handles this request

        System.out.println("\nRequesting approval for amount 10000:");
        manager.approveRequest(10000);  // CEO handles this request
    }
}

输出结果：

Requesting approval for amount 500:
Manager approved request of amount 500

Requesting approval for amount 3000:
Director approved request of amount 3000

Requesting approval for amount 10000:
CEO approved request of amount 10000

各种变形用法完整示例

  1. 动态责任链

    在某些情况下，责任链的顺序可能并不是固定的。可以动态设置处理者链条，从而灵活地控制请求的传递顺序。

    代码示例：动态责任链

    java 复制代码 
    public class DynamicChainDemo {
    public static void main(String[] args) {
        Approver manager = new Manager();
        Approver director = new Director();
        Approver ceo = new CEO();

        // 动态设置责任链
        director.setNextApprover(manager);  // 将总监设置为经理的下一个处理者
        ceo.setNextApprover(director);      // 将CEO设置为总监的下一个处理者

        // 提交请求
        System.out.println("Requesting approval for amount 2000:");
        ceo.approveRequest(2000);  // 由于链条是动态的，总监会首先处理
    }
}

    输出结果：

    Requesting approval for amount 2000:
Director approved request of amount 2000

  2. 双向责任链

    有时请求可能需要在链条中向前或向后传递。在这种情况下，可以实现双向责任链。

    代码示例：双向责任链

    java 复制代码 
    abstract class BiDirectionalApprover {
    protected BiDirectionalApprover nextApprover;
    protected BiDirectionalApprover prevApprover;

    public void setNextApprover(BiDirectionalApprover nextApprover) {
        this.nextApprover = nextApprover;
    }

    public void setPrevApprover(BiDirectionalApprover prevApprover) {
        this.prevApprover = prevApprover;
    }

    public abstract void approveRequest(int amount);
}

class ManagerBiDirectional extends BiDirectionalApprover {
    @Override
    public void approveRequest(int amount) {
        if (amount <= 1000) {
            System.out.println("Manager approved request of amount " + amount);
        } else if (nextApprover != null) {
            nextApprover.approveRequest(amount);
        } else if (prevApprover != null) {
            prevApprover.approveRequest(amount);  // 向前传递
        }
    }
}

// 双向链条示例
public class BiDirectionalChainDemo {
    public static void main(String[] args) {
        BiDirectionalApprover manager = new ManagerBiDirectional();
        BiDirectionalApprover director = new DirectorBiDirectional();
        BiDirectionalApprover ceo = new CEO();

        // 设置链条
        manager.setNextApprover(director);
        director.setPrevApprover(manager);

        // 请求
        manager.approveRequest(2000);
    }
}

  3. 链式日志处理

    在日志系统中，可以使用责任链模式实现日志的逐级过滤。例如，只输出大于某个级别的日志。

    代码示例：链式日志处理

    java 复制代码 
    // 抽象日志处理者
abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    protected abstract void write(String message);
}

// 具体日志处理者
class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Console Logger: " + message);
    }
}

class FileLogger extends Logger {
    public FileLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File Logger: " + message);
    }
}
 // 日志系统示例
public class LoggerDemo {
    public static void main(String[] args) {
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);
        Logger fileLogger = new FileLogger(Logger.ERROR);

        // 设置链条
        consoleLogger.setNextLogger(fileLogger);

        consoleLogger.logMessage(Logger.INFO, "This is an information.");
        consoleLogger.logMessage(Logger.ERROR, "This is an error message.");
    }
}

通过这些示例，可以灵活运用责任链模式，根据业务需求构建多种责任链。

相关推荐
Slow菜鸟2 天前
Spring 设计模式之责任链模式
spring·设计模式·责任链模式
zzzhpzhpzzz4 天前
设计模式——责任链模式
设计模式·责任链模式
凯雄，长沙起风了、6 天前
设计模式之责任链的通用实践思考
spring·设计模式·责任链模式·责任链实践
wrx繁星点点6 天前
责任链模式：解耦请求处理的设计模式
java·开发语言·设计模式·tomcat·maven·intellij-idea·责任链模式
?abc!8 天前
设计模式基础概念（行为模式）：责任链模式（Chain Of Responsibility）
设计模式·责任链模式
迷路国王9 天前
Android 利用责任链模式来实现 解析不同的json对象
android·json·责任链模式
麦克·唐21 天前
责任链模式（C++）
c++·责任链模式
王先生草1 个月前
设计模式---责任链模式快速demo
设计模式·责任链模式
anyup_前端梦工厂1 个月前
JS设计模式之职责链模式：优雅地处理请求流程
前端·javascript·设计模式·责任链模式
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play