责任链模式（Chain of Responsibility Pattern）[编辑 | 编辑源代码]

责任链模式是一种行为设计模式，它允许你将请求沿着处理链传递，直到有一个处理者能够处理该请求为止。这种模式解耦了请求的发送者和接收者，允许多个对象都有机会处理请求。

介绍[编辑 | 编辑源代码]

责任链模式的核心思想是构建一条处理链，每个处理者（Handler）都包含对下一个处理者的引用。当一个请求进入链时，处理者可以选择处理请求或将其传递给链中的下一个处理者。这种模式常用于：

多级审批流程
事件处理系统
日志记录器
异常处理

结构[编辑 | 编辑源代码]

责任链模式通常包含以下组件：

Handler（抽象处理者）：定义处理请求的接口，通常包含一个处理方法和设置下一个处理者的方法
ConcreteHandler（具体处理者）：实现处理请求的具体逻辑，决定是否处理请求或传递给下一个处理者
Client（客户端）：创建处理链并向链头发送请求

代码示例[编辑 | 编辑源代码]

以下是一个简单的责任链模式实现示例，模拟不同级别的日志记录器：

// 抽象处理者
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);
        }
    }
    
    abstract protected void write(String message);
}

// 具体处理者1
class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }
    
    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}

// 具体处理者2
class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }
    
    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}

// 具体处理者3
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, "This is an information.");
        loggerChain.logMessage(Logger.DEBUG, "This is a debug level information.");
        loggerChain.logMessage(Logger.ERROR, "This is an error information.");
    }
}

输出结果：

Standard Console::Logger: This is an information.
File::Logger: This is a debug level information.
Standard Console::Logger: This is a debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

实际应用案例[编辑 | 编辑源代码]

责任链模式在现实世界中有许多应用场景：

1. Web框架中的中间件处理：

  - Express.js、Spring等框架使用责任链模式处理HTTP请求
  - 每个中间件可以决定是否处理请求或传递给下一个中间件

2. Java Servlet过滤器：

  - 多个过滤器组成处理链，每个过滤器可以处理请求或传递给下一个过滤器

3. GUI事件处理：

  - 事件从最具体的组件（如按钮）向上传递到容器组件

4. 审批系统：

  - 不同级别的审批人组成处理链，如请假审批流程

优缺点[编辑 | 编辑源代码]

优点：

降低耦合度：请求发送者不需要知道哪个对象会处理请求
动态增加或修改处理链：可以灵活地调整处理者顺序或增加新的处理者
单一职责原则：每个处理者只需关注自己的处理逻辑

缺点：

请求可能未被处理：如果链中没有合适的处理者，请求可能到达链尾而未被处理
性能问题：长链可能导致处理延迟
调试困难：请求的传递路径可能不直观，增加调试难度

变体与相关模式[编辑 | 编辑源代码]

纯责任链：处理者必须处理请求或传递给下一个处理者，不能两者都做
不纯责任链：处理者可以处理请求后继续传递（如上面的日志示例）
相关模式：

 - 与命令模式结合：将请求封装为命令对象
 - 与组合模式结合：构建树形处理结构

责任链可以形式化为： $C = {H_{1}, H_{2}, . . ., H_{n}}$ 其中每个处理者 $H_{i}$ 包含： $H_{i} = (P_{i}, S_{i})$ $P_{i}$ 是处理条件， $S_{i}$ 是处理逻辑。请求 $R$ 在链中的处理过程为： $handle (R) = {\begin{cases} S_{i} (R) & if P_{i} (R) \\ {handle}_{i + 1} (R) & otherwise \end{cases}$

总结[编辑 | 编辑源代码]

责任链模式提供了一种优雅的方式来处理需要多个对象处理的请求。通过将处理者连接成链，你可以灵活地组织处理逻辑，而不需要硬编码处理顺序。这种模式特别适合处理需要多级处理或审批的场景，但需要注意控制链的长度以避免性能问题。