「软件设计模式」责任链模式（Chain of Responsibility）

「软件设计模式」责任链模式（Chain of Responsibility）

引用

CSDN

1.

https://m.blog.csdn.net/ThereIsNoCode/article/details/145828505

责任链模式（Chain of Responsibility）是一种行为设计模式，它将多个处理对象连接成链，并沿着链条传递请求，直到有对象处理它为止。这种模式实现了请求发送者与接收者的解耦，广泛应用于多级审批、过滤系统、事件处理等场景。本文将通过C++实现请假审批系统，深入解析责任链模式的核心思想和应用场景。

引言：当审批流程遇上设计模式

在软件系统中，我们经常会遇到这样的场景：一个请求需要经过多个处理节点的判断，每个节点都有权决定是否处理或传递请求。就像企业的请假审批流程，可能经历「主管→经理→总监」三级判断。如何优雅地实现这种传递机制？责任链模式给出了完美解决方案。

一、责任链模式核心思想

1.1 模式定义

责任链模式（Chain of Responsibility）通过将多个处理对象连接成链，并沿着链条传递请求，直到有对象处理它为止。这种模式实现了请求发送者与接收者的解耦。

1.2 模式结构

• Handler：定义处理请求的接口，维护后继者引用
• ConcreteHandler：具体处理者，实现处理逻辑
• Client：装配处理链，发起请求

二、C++实现请假审批系统

我们以三级审批流程为例，演示如何用C++实现责任链模式。

2.1 抽象处理者

#include <iostream>
#include <memory>
// 请假请求结构体
struct LeaveRequest {
    int employeeId;
    std::string name;
    int leaveDays;
};
// 抽象处理者
class Handler {
protected:
    std::shared_ptr<Handler> nextHandler;
public:
    virtual ~Handler() = default;
    
    void setNext(std::shared_ptr<Handler> handler) {
        nextHandler = handler;
    }
    virtual void handleRequest(const LeaveRequest& request) = 0;
};  

2.2 具体处理者实现

// 主管审批（处理<=3天的请假）
class Supervisor : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.leaveDays <= 3) {
            std::cout << "主管批准了" << request.name 
                      << "的" << request.leaveDays << "天请假
";
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};
// 部门经理审批（处理<=7天的请假）
class Manager : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.leaveDays <= 7) {
            std::cout << "经理批准了" << request.name 
                      << "的" << request.leaveDays << "天请假
";
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};
// 总经理审批（处理>7天的请假）
class GeneralManager : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.leaveDays > 7) {
            std::cout << "总经理批准了" << request.name 
                      << "的" << request.leaveDays << "天请假
";
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};  

2.3 构建责任链

int main() {
    // 创建处理者
    auto supervisor = std::make_shared<Supervisor>();
    auto manager = std::make_shared<Manager>();
    auto generalManager = std::make_shared<GeneralManager>();
    // 构建责任链
    supervisor->setNext(manager);
    manager->setNext(generalManager);
    // 模拟请假请求
    LeaveRequest requests[] = {
        {101, "张三", 2},
        {102, "李四", 5},
        {103, "王五", 9}
    };
    // 处理所有请求
    for (const auto& req : requests) {
        std::cout << "\n处理" << req.name << "的请求：n";
        supervisor->handleRequest(req);
    }
    return 0;
}  

2.4 运行结果

处理张三的请求：
主管批准了张三的2天请假
处理李四的请求：
经理批准了李四的5天请假
处理王五的请求：
总经理批准了王五的9天请假

三、模式应用场景

1. 多级过滤系统：如敏感词过滤、网络请求拦截
2. 动态流程处理：可配置的审批流程
3. 事件处理系统：GUI事件冒泡机制
4. 中间件管道：Web服务器中间件处理

四、模式优缺点分析

✅优势：

• 请求与处理解耦
• 动态调整处理链顺序
• 符合开闭原则（新增处理者无需修改已有代码）

❌局限：

• 请求可能未被处理（需设置默认处理）
• 长链影响性能（可考虑设置最大传递次数）

五、扩展与变体

1. 组合模式：处理链嵌套形成树形结构
2. 拦截过滤器：处理完成后反向传递
3. 异步责任链：非阻塞式处理（需考虑线程安全）

结语：链式思维的力量

责任链模式将离散的处理节点组织成灵活的执行链路，这种设计思想在C++标准库中也有体现（如异常处理栈）。掌握该模式的关键在于理解处理节点的独立性，以及如何构建高效的传递机制。当你的系统需要灵活多变的处理流程时，不妨考虑让责任链来大显身手！

本文原文来自CSDN，作者：ThereIsNoCode