相关文章：技术成神之路：二十三种设计模式(导航页)

介绍

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象依次处理请求，避免请求的发送者和接收者之间的显式耦合。该模式通过将多个可能处理请求的对象连接成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

1.定义

---

责任链模式为请求创建一个接收者对象的链。这种模式给予多个对象处理请求的机会，从而解耦发送者和接收者。

2.主要作用

---

1. 解耦发送者和接收者：发送者无需知道链中的具体接收者，只需将请求发送给链的头部。每个接收者只需要实现处理请求的方法即可。

2. 动态的处理链：责任链可以动态配置和调整，可以根据需要增加或修改链中的处理者，灵活性较高。

3. 增强可扩展性：可以根据业务需求方便地增加或者修改处理节点，符合开闭原则。

3.解决的问题

---

空口无凭，咱举例说明😉😉

3.1 解耦发送者和接收者

示例：
在一个电商系统中，订单的支付方式验证可以通过责任链模式来处理。例如，支付方式验证可以依次由信用卡支付、支付宝、微信支付等组成一个处理链，系统根据订单中选择的支付方式逐个验证，直到找到能够处理该支付方式的处理者。

3.2 动态确定处理链

示例：
在一个工作流系统中，根据不同的流程状态和权限要求，可以动态地配置审批流程。例如，一个采购审批流程可能需要在不同金额范围内由不同级别的管理者审批，责任链模式可以根据采购金额动态确定审批人。

3.3 增强系统的可扩展性

示例：
在一个日志记录系统中，可以使用责任链模式来处理日志的级别。例如，如果日志级别是DEBUG，则可以由DebugLogger处理；如果是INFO，则由InfoLogger处理；如果是ERROR，则由ErrorLogger处理。如果未来增加了新的日志级别，只需添加新的处理者即可，不影响原有代码。

4.模式原理

---

包含角色：

1. 抽象处理者（Handler）：定义处理请求的接口，并维护一个指向下一个处理者的引用。
2. 具体处理者（ConcreteHandler）：实现抽象处理者的接口，处理请求的具体逻辑。如果可以处理请求，则处理；否则将请求传递给下一个处理者。
3. 客户端（Client）：创建责任链，并将请求发送给链的第一个处理者。

UML类图：

示例代码：

定义处理器接口

abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    //next element in chain or responsibility
    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);
        }
    }

    abstract protected void write(String message);
}

创建具体的处理器

class ConsoleLogger extends Logger {

    public ConsoleLogger(int level){
        this.level = level;
    }

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

class ErrorLogger extends Logger {

    public ErrorLogger(int level){
        this.level = level;
    }

    @Override
    protected void write(String message) {        
        System.out.println("Error 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 ChainPatternDemo {
    
    private static Logger getChainOfLoggers(){

        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger fileLogger = new FileLogger(Logger.DEBUG);
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;  
    }

    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(Logger.INFO, "这是一个信息.");
        loggerChain.logMessage(Logger.DEBUG, "这是一个debug信息.");
        loggerChain.logMessage(Logger.ERROR, "这是一个error信息.");
    }
}

上面代码创建了一个日志处理链：错误日志处理器 -> 文件日志处理器 -> 控制台日志处理器。根据日志消息的级别，消息会被相应级别的处理器处理，如果这个处理器级别不足以处理该消息，则消息会传递给链中的下一个处理器。

5.优缺点

---

优点：

• 降低耦合度
• 增加新的命令处理类很方便

缺点：

• 不能保证请求一定被接收： 就像switch要加default一样，在链的末端未被处理。
• 性能问题：如果链条过长可能会出现性能问题，几乎可以忽略。

6.应用场景

---

1. 多级请求：当一个请求可以由多个对象来处理，但具体由哪个对象处理则在运行时动态决定。
2. 审批流程：如公司的采购审批、请假审批等，每个审批阶段都可以视为链上的一个处理节点。
3. 事件处理系统：如GUI中的事件处理或者框架中的事件传递，比如Java的AWT或Swing。
4. 日志记录：根据消息的严重性级别决定日志记录的方式，各种处理方式如写入文件、通过电子邮件发送或其他。
5. 拦截过滤器：网络请求的拦截过滤也可以使用责任链模式设计，例如Servlet的Filter链。
6. …

7.总结

---

责任链模式与我们的生活息息相关，比如：项目出了严重BUG 需要找到责任人，测试，开发，项目经理总要有一个来背锅的，还有 村长、乡长、县长、市长… 一级一级的就构成了一条链，可能举例不是很恰当，但大概就是这个意思，这种设计模式提高了系统的灵活性和可扩展性，符合开闭原则和单一职责原则，但也需要注意处理者的配置和性能问题。