编辑“︁责任链模式（Chain of Responsibility Pattern）”︁

= 责任链模式（Chain of Responsibility Pattern） =

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

== 介绍 ==
责任链模式的核心思想是构建一条处理链，每个处理者（Handler）都包含对下一个处理者的引用。当一个请求进入链时，处理者可以选择处理请求或将其传递给链中的下一个处理者。这种模式常用于：
* 多级审批流程
* 事件处理系统
* 日志记录器
* 异常处理

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

<mermaid>
classDiagram
    class Handler {
        +successor: Handler
        +handleRequest(request)
        +setSuccessor(successor)
    }
    class ConcreteHandlerA {
        +handleRequest(request)
    }
    class ConcreteHandlerB {
        +handleRequest(request)
    }
    class Client {
        +main()
    }
    Handler <|-- ConcreteHandlerA
    Handler <|-- ConcreteHandlerB
    Handler o-- Handler : successor
    Client --> Handler
</mermaid>

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

<syntaxhighlight lang="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);
        }
    }
    
    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.");
    }
}
</syntaxhighlight>

'''输出结果：'''
<pre>
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.
</pre>

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

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

2. '''Java Servlet过滤器'''：
   - 多个过滤器组成处理链，每个过滤器可以处理请求或传递给下一个过滤器

3. '''GUI事件处理'''：
   - 事件从最具体的组件（如按钮）向上传递到容器组件

4. '''审批系统'''：
   - 不同级别的审批人组成处理链，如请假审批流程

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

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

== 变体与相关模式 ==
* '''纯责任链'''：处理者必须处理请求或传递给下一个处理者，不能两者都做
* '''不纯责任链'''：处理者可以处理请求后继续传递（如上面的日志示例）
* '''相关模式'''：
  - 与[[命令模式]]结合：将请求封装为命令对象
  - 与[[组合模式]]结合：构建树形处理结构

== 数学表示 ==
责任链可以形式化为：
<math>
C = \{H_1, H_2, ..., H_n\}
</math>
其中每个处理者<math>H_i</math>包含：
<math>
H_i = (P_i, S_i)
</math>
<math>P_i</math>是处理条件，<math>S_i</math>是处理逻辑。请求<math>R</math>在链中的处理过程为：
<math>
\text{handle}(R) = \begin{cases}
S_i(R) & \text{if } P_i(R) \\
\text{handle}_{i+1}(R) & \text{otherwise}
\end{cases}
</math>

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

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:设计模式]]