C++ 责任链模式详解

时间：2025-05-14 20:31:05

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许你将请求沿着处理链传递，直到有一个处理者能够处理它为止。

核心概念

设计原则

责任链模式遵循以下设计原则：

  1. 单一职责原则：每个处理者只关注自己能够处理的请求

  2. 开闭原则：可以新增处理者而不修改现有代码

  3. 松耦合：请求发送者与接收者解耦

主要优点

  1. 动态链：可以动态改变处理链

  2. 解耦：发送者不需要知道具体处理者

  3. 灵活性：可以灵活添加或修改处理流程

  4. 顺序控制：可以控制处理者的顺序

模式结构

主要组件

  1. Handler（处理者接口）

    • 定义处理请求的接口

    • 通常包含设置下一个处理者的方法

  2. ConcreteHandler（具体处理者）

    • 实现处理请求的具体逻辑

    • 如果不能处理，将请求转发给下一个处理者

  3. Client（客户端）

    • 组装处理链

    • 发起请求

完整代码示例

#include <iostream>
#include <memory>
#include <string>
#include <vector>

// ==================== 请求类 ====================
class Request {
    std::string type_;
    std::string content_;
    int level_;
    
public:
    Request(const std::string& type, const std::string& content, int level)
        : type_(type), content_(content), level_(level) {}
    
    std::string getType() const { return type_; }
    std::string getContent() const { return content_; }
    int getLevel() const { return level_; }
};

// ==================== 处理者接口 ====================
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 Request& req) = 0;
};

// ==================== 具体处理者 ====================
class JuniorManager : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.getLevel() <= 1) {
            std::cout << "初级经理处理请求: " << req.getContent() 
                      << " (级别: " << req.getLevel() << ")" << std::endl;
        } else if (nextHandler_) {
            std::cout << "初级经理无法处理，转交给上级..." << std::endl;
            nextHandler_->handleRequest(req);
        } else {
            std::cout << "请求无法处理: " << req.getContent() << std::endl;
        }
    }
};

class SeniorManager : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.getLevel() <= 3) {
            std::cout << "高级经理处理请求: " << req.getContent() 
                      << " (级别: " << req.getLevel() << ")" << std::endl;
        } else if (nextHandler_) {
            std::cout << "高级经理无法处理，转交给上级..." << std::endl;
            nextHandler_->handleRequest(req);
        } else {
            std::cout << "请求无法处理: " << req.getContent() << std::endl;
        }
    }
};

class Director : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.getLevel() <= 5) {
            std::cout << "总监处理请求: " << req.getContent() 
                      << " (级别: " << req.getLevel() << ")" << std::endl;
        } else if (nextHandler_) {
            std::cout << "总监无法处理，转交给上级..." << std::endl;
            nextHandler_->handleRequest(req);
        } else {
            std::cout << "请求无法处理: " << req.getContent() << std::endl;
        }
    }
};

class CEO : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (req.getLevel() <= 10) {
            std::cout << "CEO处理请求: " << req.getContent() 
                      << " (级别: " << req.getLevel() << ")" << std::endl;
        } else {
            std::cout << "CEO也无法处理此重要请求: " << req.getContent() << std::endl;
        }
    }
};

// ==================== 客户端代码 ====================
int main() {
    std::cout << "=== 责任链模式演示: 公司审批流程 ===" << std::endl;
    
    // 创建处理者
    auto junior = std::make_shared<JuniorManager>();
    auto senior = std::make_shared<SeniorManager>();
    auto director = std::make_shared<Director>();
    auto ceo = std::make_shared<CEO>();
    
    // 构建责任链
    junior->setNext(senior);
    senior->setNext(director);
    director->setNext(ceo);
    
    // 创建不同级别的请求
    std::vector<Request> requests = {
        Request("请假", "张三请病假1天", 1),
        Request("采购", "购买办公用品预算500元", 2),
        Request("项目", "启动新项目预算5万元", 4),
        Request("投资", "收购某公司预算5000万元", 8),
        Request("战略", "公司重组方案", 12)
    };
    
    // 处理请求
    for (const auto& req : requests) {
        std::cout << "\n处理请求: " << req.getType() << " - " << req.getContent() << std::endl;
        junior->handleRequest(req);
    }
    
    return 0;
}

模式变体

1. 使用函数对象作为处理者

#include <functional>
#include <vector>

class FunctionalHandler {
    using HandlerFunc = std::function<bool(const Request&)>;
    std::vector<HandlerFunc> handlers_;
    
public:
    void addHandler(HandlerFunc handler) {
        handlers_.push_back(handler);
    }
    
    void handle(const Request& req) {
        for (const auto& handler : handlers_) {
            if (handler(req)) {
                return; // 请求已处理
            }
        }
        std::cout << "没有处理者能处理此请求" << std::endl;
    }
};

// 使用示例
void functionalExample() {
    FunctionalHandler chain;
    
    chain.addHandler([](const Request& req) {
        if (req.getLevel() <= 1) {
            std::cout << "处理级别1请求: " << req.getContent() << std::endl;
            return true;
        }
        return false;
    });
    
    chain.addHandler([](const Request& req) {
        if (req.getLevel() <= 3) {
            std::cout << "处理级别3请求: " << req.getContent() << std::endl;
            return true;
        }
        return false;
    });
    
    Request req("测试", "功能处理测试", 2);
    chain.handle(req);
}

2. 中断链与组合处理

class CompositeHandler : public Handler {
    std::vector<std::shared_ptr<Handler>> handlers_;
    
public:
    void addHandler(std::shared_ptr<Handler> handler) {
        handlers_.push_back(handler);
    }
    
    void handleRequest(const Request& req) override {
        for (const auto& handler : handlers_) {
            handler->handleRequest(req);
            // 不自动传递，每个处理者都尝试处理
        }
    }
};

class TerminatingHandler : public Handler {
public:
    void handleRequest(const Request& req) override {
        if (canHandle(req)) {
            std::cout << "处理并终止链: " << req.getContent() << std::endl;
        } else if (nextHandler_) {
            nextHandler_->handleRequest(req);
        } else {
            std::cout << "请求未被处理" << std::endl;
        }
    }
    
    bool canHandle(const Request& req) {
        return req.getType() == "紧急";
    }
};

实际应用场景

  1. 审批流程：如示例中的多级审批

  2. 事件处理：GUI事件冒泡或捕获机制

  3. 中间件管道：Web请求处理管道

  4. 异常处理：多层异常捕获机制

  5. 日志过滤：不同级别的日志处理

相关文章