编辑“︁Java责任链模式”︁

{{Note|本条目是[[Java设计模式]]系列的一部分，介绍'''责任链模式'''（Chain of Responsibility Pattern）的概念、实现及应用场景。}}

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

主要特点：
* 请求沿着链传递，直到被处理或到达链尾
* 每个处理者决定是否处理请求或传递给下一个处理者
* 动态添加或修改处理链

== 结构 ==
责任链模式包含以下核心组件：
* '''Handler'''（抽象处理者）：定义处理请求的接口
* '''ConcreteHandler'''（具体处理者）：实现处理逻辑，决定是否处理请求或传递
* '''Client'''（客户端）：创建处理链并提交请求

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

== 代码示例 ==
以下是一个简单的审批流程示例：

<syntaxhighlight lang="java">
// 抽象处理者
abstract class Approver {
    protected Approver successor;

    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    public abstract void processRequest(PurchaseRequest request);
}

// 具体处理者：经理
class Manager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 1000) {
            System.out.println("Manager approves purchase #" + request.getNumber());
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

// 具体处理者：总监
class Director extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() <= 5000) {
            System.out.println("Director approves purchase #" + request.getNumber());
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

// 请求类
class PurchaseRequest {
    private int number;
    private double amount;

    public PurchaseRequest(int number, double amount) {
        this.number = number;
        this.amount = amount;
    }

    // getters...
}

// 客户端
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Approver manager = new Manager();
        Approver director = new Director();
        
        manager.setSuccessor(director);
        
        // 创建不同金额的采购请求
        manager.processRequest(new PurchaseRequest(1, 500));
        manager.processRequest(new PurchaseRequest(2, 2500));
        manager.processRequest(new PurchaseRequest(3, 6000));
    }
}
</syntaxhighlight>

输出结果：
<pre>
Manager approves purchase #1
Director approves purchase #2
</pre>

== 实际应用场景 ==
责任链模式在以下场景中特别有用：

1. '''多级审批系统'''：如采购审批、请假审批等
2. '''事件处理'''：如GUI中的事件冒泡机制
3. '''日志记录'''：不同级别的日志由不同处理器处理
4. '''异常处理'''：try-catch块形成的处理链
5. '''Web过滤器'''：Servlet过滤器链

== 变体与注意事项 ==
=== 纯与不纯的责任链 ===
* '''纯责任链'''：请求必须被某个处理者处理
* '''不纯责任链'''：请求可能不被任何处理者处理

=== 性能考虑 ===
* 避免过长的处理链影响性能
* 可以考虑短路机制（找到处理者后立即终止）

=== 与其他模式的关系 ===
* 与[[组合模式]]：可以用组合结构实现处理链
* 与[[装饰器模式]]：都基于递归组合，但目的不同

== 数学表示 ==
责任链可以形式化为：
<math>
C = \{h_1, h_2, ..., h_n\} \\
\forall r \in R, \exists h_i \in C : h_i(r) \neq \emptyset \Rightarrow \text{处理成功}
</math>
其中：
* <math>C</math>是处理链
* <math>h_i</math>是处理者
* <math>R</math>是所有可能的请求集合

== 高级主题 ==
=== 动态链构建 ===
可以通过配置文件或依赖注入框架动态构建处理链：
<syntaxhighlight lang="java">
// 使用Spring框架的示例
@Configuration
public class ChainConfig {
    @Bean
    @Order(1)
    public Handler firstHandler() {
        return new FirstHandler();
    }
    
    @Bean
    @Order(2)
    public Handler secondHandler() {
        return new SecondHandler();
    }
}
</syntaxhighlight>

=== 中断处理 ===
某些实现可能允许处理者中断链的继续传递：
<syntaxhighlight lang="java">
public void processRequest(Request request) {
    if (canHandle(request)) {
        handle(request);
        return; // 中断传递
    }
    if (successor != null) {
        successor.processRequest(request);
    }
}
</syntaxhighlight>

== 最佳实践 ==
1. 考虑使用构建器模式来创建复杂的处理链
2. 为处理链添加监控和日志记录能力
3. 避免形成循环链
4. 考虑使用空对象模式处理未被处理的请求

{{JavaDesignPatterns}}

[[Category:Java设计模式]]
[[Category:行为模式]]

[[Category:编程语言]]
[[Category:Java]]