职责链模式应用场景与C++实现_c++ 职责链模式应用场景-优快云博客

1. 职责链模式核心思想
定义：使多个对象都有机会处理请求，从而避免请求发送者与接收者耦合。将这些对象连成一条链，并沿着链传递请求直到被处理。

核心组件：

Handler：定义处理请求的接口，包含设置后继者的方法

ConcreteHandler：具体处理器，实现处理逻辑或转发请求

Client：创建处理链并向链头发送请求

特点：

动态组合处理流程

请求者无需知道具体处理者

支持运行时链结构调整

2. 5个经典应用场景
① 多级日志过滤系统
不同级别日志（DEBUG/INFO/WARN/ERROR）由不同处理器处理，未处理日志最终交给默认处理器。

② 电商订单处理流程
订单依次通过：库存检查→支付验证→风控审核→物流分配等环节，任一环节失败则终止。

③ 游戏事件处理
游戏中的输入事件（点击/键盘/手柄）按优先级链传递，直到被某个游戏对象响应。

④ 网络请求中间件
HTTP请求经过：身份认证→权限校验→限流控制→业务处理等中间件链。

⑤ 异常处理系统
异常依次尝试：本地恢复→备用方案→日志记录→上级系统通知。

3. C++实现示例
场景模拟：公司采购审批系统
基层经理：可审批≤5000元的采购

部门总监：可审批≤20000元的采购

CFO：可审批≤100000元的采购

董事会：处理超过100000元的采购

#include <iostream>
#include <string>

// 请求类
class PurchaseRequest {
public:
    PurchaseRequest(double amount, const std::string& purpose) 
        : amount_(amount), purpose_(purpose) {}
    
    double getAmount() const { return amount_; }
    const std::string& getPurpose() const { return purpose_; }

private:
    double amount_;
    std::string purpose_;
};

// 抽象处理器
class Approver {
public:
    explicit Approver(const std::string& name) : name_(name), successor_(nullptr) {}
    
    void setSuccessor(Approver* successor) {
        successor_ = successor;
    }

    virtual void processRequest(const PurchaseRequest& request) = 0;

protected:
    std::string name_;
    Approver* successor_;  // 后继处理者
};

// 具体处理器：经理
class Manager : public Approver {
public:
    explicit Manager(const std::string& name) : Approver(name) {}
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() <= 5000) {
            std::cout << "经理" << name_ << "审批采购单："
                      << request.getAmount() << "元，目的：" 
                      << request.getPurpose() << std::endl;
        } else if (successor_ != nullptr) {
            successor_->processRequest(request);
        }
    }
};

// 具体处理器：总监
class Director : public Approver {
public:
    explicit Director(const std::string& name) : Approver(name) {}
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() <= 20000) {
            std::cout << "总监" << name_ << "审批采购单："
                      << request.getAmount() << "元，目的：" 
                      << request.getPurpose() << std::endl;
        } else if (successor_ != nullptr) {
            successor_->processRequest(request);
        }
    }
};

// 具体处理器：CFO
class CFO : public Approver {
public:
    explicit CFO(const std::string& name) : Approver(name) {}
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() <= 100000) {
            std::cout << "CFO " << name_ << "审批采购单："
                      << request.getAmount() << "元，目的：" 
                      << request.getPurpose() << std::endl;
        } else if (successor_ != nullptr) {
            successor_->processRequest(request);
        }
    }
};

// 具体处理器：董事会
class Board : public Approver {
public:
    explicit Board(const std::string& name) : Approver(name) {}
    
    void processRequest(const PurchaseRequest& request) override {
        std::cout << "董事会" << name_ << "审批重大采购单："
                  << request.getAmount() << "元，目的：" 
                  << request.getPurpose() << std::endl;
    }
};

int main() {
    // 构建责任链
    Manager manager("张经理");
    Director director("李总监");
    CFO cfo("王财务");
    Board board("全体董事");
    
    manager.setSuccessor(&director);
    director.setSuccessor(&cfo);
    cfo.setSuccessor(&board);

    // 模拟采购请求
    PurchaseRequest req1(4500, "购买办公用品");
    PurchaseRequest req2(15000, "团队建设活动");
    PurchaseRequest req3(80000, "服务器升级");
    PurchaseRequest req4(150000, "新建数据中心");

    // 处理请求（均从链头开始）
    manager.processRequest(req1);
    manager.processRequest(req2);
    manager.processRequest(req3);
    manager.processRequest(req4);

    return 0;
}

输出结果：

经理张经理审批采购单：4500元，目的：购买办公用品
总监李总监审批采购单：15000元，目的：团队建设活动
CFO 王财务审批采购单：80000元，目的：服务器升级
董事会全体董事审批重大采购单：150000元，目的：新建数据中心

4. 模式变体与优化

（1）功能增强版

// 支持中断传递的增强版处理器接口
class EnhancedApprover : public Approver {
public:
    virtual bool canHandle(const PurchaseRequest& request) const = 0;
    
    void processRequest(const PurchaseRequest& request) override {
        if (canHandle(request)) {
            // 处理逻辑...
        } else if (successor_) {
            successor_->processRequest(request);
        } else {
            std::cerr << "无法处理的请求：" << request.getPurpose() << std::endl;
        }
    }
};

（2）模板化实现

template<typename T>
class HandlerChain {
public:
    void addHandler(std::shared_ptr<T> handler) {
        if (!head_) {
            head_ = handler;
            tail_ = handler;
        } else {
            tail_->setNext(handler);
            tail_ = handler;
        }
    }
    
    void handle(const typename T::RequestType& req) {
        if (head_) head_->handle(req);
    }

private:
    std::shared_ptr<T> head_;
    std::shared_ptr<T> tail_;
};

5. 工程实践建议
链的构建：推荐使用工厂模式或依赖注入构建责任链

性能优化：对于长链可引入缓存机制（如记录上次处理节点）

监控增强：添加链调用日志，便于调试复杂流程

与其它模式结合：

组合模式：构建树形处理结构

策略模式：动态更换处理算法

命令模式：将请求对象化

职责链模式特别适用于需要动态调整处理流程的场景，是解耦请求发送者和处理者的经典解决方案。