C++设计模式-责任链模式：从基本介绍，内部原理、应用场景、使用方法，常见问题和解决方案进行深度解析

一、责任链模式的基本介绍

1.1 模式定义与核心思想

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，其核心思想是将请求的发送者和接收者解耦。通过创建一个由多个处理节点组成的链条，每个节点依次尝试处理请求。如果当前节点无法处理，则将请求传递给链中的下一个节点，直到找到合适的处理者或链尾。
这种模式的灵感来源于现实中的链式处理流程，例如：

• 公司请假审批（员工→部门经理→总经理）
• 电商订单处理（支付→库存→物流）
• 操作系统事件处理（键盘→鼠标→触摸板）

1.2 模式本质与设计原则

责任链模式通过以下方式实现设计目标：

• 单一职责原则：每个处理节点专注于特定类型的请求
• 开闭原则：新增处理节点时无需修改现有代码
• 解耦：请求发送者与接收者之间无直接依赖关系
• 灵活性：处理顺序可动态调整

1.3 模式结构与角色

责任链模式包含以下核心角色：

• 抽象处理者（Handler）：
  定义处理请求的接口（handleRequest）；
  维护下一个处理者的引用；
• 具体处理者（ConcreteHandler）：
  实现具体的请求处理逻辑；
  决定是否传递请求给下一个节点
• 客户端（Client）：
  创建责任链；
  提交请求到链的起始节点；

类结构如下：

class Handler {
public:
    virtual ~Handler() = default;
    virtual void handleRequest(Request* request) = 0;
    void setNext(Handler* next) { nextHandler = next; }
protected:
    Handler* nextHandler = nullptr;
};

class ConcreteHandlerA : public Handler {
public:
    void handleRequest(Request* request) override {
        if (canHandle(request)) {
            // 处理请求
        } else {
            if (nextHandler) {
                nextHandler->handleRequest(request);
            }
        }
    }
private:
    bool canHandle(Request* request) { /* 判断逻辑 */ }
};

二、责任链模式的内部原理

2.1 请求传递机制

责任链的核心在于请求的传递逻辑：

• 客户端将请求发送到链的起始节点；
• 当前节点检查是否能处理请求；
• 能处理则执行处理逻辑；
• 不能处理则传递给下一个节点；
• 直到请求被处理或到达链尾；

代码示例：

class Manager : public Handler {
public:
    void handleRequest(Request* request) override {
        if (request->type == RequestType::Leave) {
            if (request->days <= 3) {
                cout << "Manager approved " << request->days << " days leave" << endl;
            } else {
                if (nextHandler) {
                    nextHandler->handleRequest(request);
                }
            }
        }
    }
};

2.2 责任链的构建方式

责任链的构建通常有两种方式：
客户端构建：客户端负责组装各个处理节点

auto ceo = new CEO();
auto director = new Director();
director->setNext(ceo);
auto manager = new Manager();
manager->setNext(director);

动态构建：通过配置文件或依赖注入动态生成链

2.3 处理顺序的控制

处理顺序对系统行为有重要影响：

• 正向链：处理顺序由低到高（如初级到高级审批）
• 反向链：优先尝试高级处理者
• 动态调整：根据运行时条件改变处理顺序

示例：日志级别处理链：

void LoggerChain::addLogger(Logger* logger) 
{
    if (!firstLogger) 
    {
        firstLogger = logger;
    }
    else 
    {
        currentLogger->setNext(logger);
    }
    currentLogger = logger;
}

三、责任链模式的应用场景

3.1 典型应用场景

• 审批流程：请假、报销、订单审核；
• 请求处理：Web 请求过滤（身份验证→权限检查→日志记录）；
• 事件处理：图形界面的事件传递；
• 错误处理：异常处理链；
• 职责划分：复杂任务的分步处理；

3.2 企业级应用案例

案例 1：电商订单处理

// 支付处理
PaymentHandler paymentHandler;
// 库存检查
InventoryHandler inventoryHandler;
inventoryHandler.setNext(&paymentHandler);
// 物流调度
ShippingHandler shippingHandler;
shippingHandler.setNext(&inventoryHandler);
// 执行处理
shippingHandler.handleOrder(order);

案例 2：Web 请求处理

FilterChain filterChain;
filterChain.addFilter(new AuthenticationFilter());
filterChain.addFilter(new AuthorizationFilter());
filterChain.addFilter(new LoggingFilter());
filterChain.doFilter(request, response);

3.3 模式适用条件

当系统满足以下条件时适合使用责任链模式：

• 请求的处理流程包含多个步骤；
• 处理步骤的顺序可能动态变化；
• 需要灵活地新增或删除处理步骤；
• 需要避免请求发送者与接收者之间的直接耦合；

四、责任链模式的使用方法

4.1 实现步骤详解

• 定义请求类

class Request {
public:
    enum class Type { Leave, Overtime, Reimbursement };
    Type type;
    int days;
    double amount;
};

• 创建抽象处理者

class Approver : public Handler {
public:
    virtual bool canApprove(Request* request) = 0;
    void handleRequest(Request* request) override {
        if (canApprove(request)) 
        {
            processRequest(request);
        } 
        else 
        {
            if (nextHandler) 
            {
                nextHandler->handleRequest(request);
            }
        }
    }
protected:
    virtual void processRequest(Request* request) = 0;
};

• 实现具体处理者

class TeamLeader : public Approver {
public:
    bool canApprove(Request* request) override {
        return request->type == Request::Type::Leave && request->days <= 2;
    }
protected:
    void processRequest(Request* request) override {
        cout << "Team leader approved " << request->days << " days leave" << endl;
    }
};

• 构建责任链

auto ceo = new CEO();
auto director = new Director();
director->setNext(ceo);
auto manager = new Manager();
manager->setNext(director);
auto teamLeader = new TeamLeader();
teamLeader->setNext(manager);

• 提交请求

Request* request = new Request{Request::Type::Leave, 5};
teamLeader->handleRequest(request);

4.2 代码实现技巧

• 模板方法模式结合：将公共处理逻辑上移到抽象类
• 请求类型枚举：使用 enum 或类型标签标识请求类型
• 智能指针管理链：使用 std::shared_ptr 防止内存泄漏
• 链式调用：提供便捷的 addNext 方法简化链构建

示例：智能指针管理

using HandlerPtr = std::shared_ptr<Handler>;

class Handler {
public:
    void setNext(HandlerPtr next) { nextHandler = next; }
private:
    HandlerPtr nextHandler;
};

五、常见问题及解决方案

5.1 常见问题分析

• 问题 1：责任链终止条件不明确：
  现象：请求到达链尾仍未被处理；
  原因：缺少最终处理节点或条件判断错误；
• 问题 2：处理顺序混乱：
  现象：请求被错误的处理者处理；
  原因：链的组装顺序错误；
• 问题 3：性能问题：
  现象：链过长导致处理延迟；
  原因：线性遍历所有节点；
• 问题 4：循环依赖：
  现象：节点间相互引用导致内存泄漏；
  原因：链构建时形成闭环；

5.2 解决方案

方案 1：设置默认处理者

class FallbackHandler : public Handler {
public:
    void handleRequest(Request* request) override {
        cout << "Request " << request->type << " cannot be handled" << endl;
    }
};

// 使用时添加到链尾
teamLeader->setNext(fallbackHandler);

方案 2：责任链验证机制

void validateChain(Handler* handler) {
    std::set<Handler*> visited;
    while (handler) {
        if (visited.count(handler)) {
            throw std::runtime_error("Cycle detected in chain");
        }
        visited.insert(handler);
        handler = handler->getNext();
    }
}

方案 3：优化处理逻辑

• 提前终止：在能处理的节点立即返回；
• 缓存处理结果：避免重复计算；
• 并行处理：使用多线程处理独立节点；

方案 4：使用组合模式
将多个处理者组合成复合处理者：

class CompositeHandler : public Handler {
public:
    void addHandler(Handler* handler) { handlers.push_back(handler); }
    void handleRequest(Request* request) override {
        for (auto& handler : handlers) {
            if (handler->canHandle(request)) {
                handler->handleRequest(request);
                return; // 找到第一个匹配的处理者
            }
        }
        // 传递给下一个节点
        if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
private:
    std::vector<Handler*> handlers;
};

六、总结与最佳实践

6.1 模式优点

• 解耦请求与处理：客户端无需知道具体处理者；
• 灵活扩展：新增处理者只需修改链结构；
• 动态控制：可以在运行时调整处理顺序；
• 单一职责：每个处理者专注特定功能；

6.2 模式缺点

• 调试困难：请求的传递路径难以跟踪；
• 性能损耗：链过长会导致处理时间增加；
• 资源消耗：每个请求可能遍历整个链；
• 责任分散：可能导致职责划分不清晰；

6.3 最佳实践建议

• 明确链的终止条件：始终包含一个最终处理者；
• 控制链的长度：避免过多的处理节点；
• 使用日志记录：记录请求的处理路径；
• 优先使用组合而非继承：通过组合方式构建链；
• 考虑性能优化：对于高频请求使用缓存或索引；

6.4 未来发展趋势

• 与响应式编程结合：利用 Rx 链处理异步请求；
• 智能链优化：根据历史数据动态调整处理顺序；
• 云原生适配：在微服务架构中实现跨服务责任链；
• AOP 集成：通过 Aspect-Oriented Programming 增强处理逻辑；

附上一个完整的代码示例：

#include <iostream>
#include <memory>

using namespace std;

// 请求类
class Request {
public:
    enum class Type { Leave, Overtime, Reimbursement };
    Type type;
    int days;
    double amount;
};

// 抽象处理者
class Approver {
public:
    virtual bool canApprove(Request* request) = 0;
    virtual void processRequest(Request* request) = 0;
    void handleRequest(Request* request) {
        if (canApprove(request)) {
            processRequest(request);
        } else {
            if (next) {
                next->handleRequest(request);
            } else {
                cout << "Request cannot be handled" << endl;
            }
        }
    }
    void setNext(unique_ptr<Approver> n) { next = move(n); }
private:
    unique_ptr<Approver> next;
};

// 具体处理者
class TeamLeader : public Approver {
public:
    bool canApprove(Request* request) override {
        return request->type == Request::Type::Leave && request->days <= 2;
    }
    void processRequest(Request* request) override {
        cout << "Team leader approved " << request->days << " days leave" << endl;
    }
};

class Manager : public Approver {
public:
    bool canApprove(Request* request) override {
        return request->type == Request::Type::Leave && request->days <= 5;
    }
    void processRequest(Request* request) override {
        cout << "Manager approved " << request->days << " days leave" << endl;
    }
};

class Director : public Approver {
public:
    bool canApprove(Request* request) override {
        return request->type == Request::Type::Leave && request->days <= 10;
    }
    void processRequest(Request* request) override {
        cout << "Director approved " << request->days << " days leave" << endl;
    }
};

// 客户端代码
int main() {
    // 构建责任链
    auto ceo = make_unique<Approver>(); // 假设CEO处理所有超过10天的请求
    auto director = make_unique<Director>();
    director->setNext(move(ceo));
    auto manager = make_unique<Manager>();
    manager->setNext(move(director));
    auto teamLeader = make_unique<TeamLeader>();
    teamLeader->setNext(move(manager));

    // 创建请求
    Request request;
    request.type = Request::Type::Leave;
    request.days = 7;

    // 提交请求
    teamLeader->handleRequest(&request);

    return 0;
}