【C++】责任链模式

原创于 2025-06-27 09:25:14 发布 · 522 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #责任链模式 #设计模式

设计模式专栏收录该内容

24 篇文章

订阅专栏

一、模式核心概念与结构
二、C++ 实现示例：员工请假审批系统
三、责任链模式的关键特性
四、应用场景
五、责任链模式与其他设计模式的关系
六、C++ 标准库中的责任链模式应用
七、优缺点分析
八、实战案例：Web 请求过滤器链
九、实现注意事项
- 如果这篇文章对你有所帮助，渴望获得你的一个点赞！

责任链模式（Chain of Responsibility Pattern）是一种【行为型】设计模式，它允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求为止。这种模式将请求的发送者和接收者解耦，使得多个处理者都有机会处理请求，而无需客户端直接知道具体的处理者。

一、模式核心概念与结构

责任链模式包含三个核心角色：

抽象处理者（Handler）：定义处理请求的接口，通常包含一个指向下一个处理者的引用。
具体处理者（Concrete Handler）：实现抽象处理者接口，处理请求或转发给下一个处理者。
客户端（Client）：创建处理者链并向链头发送请求。

二、C++ 实现示例：员工请假审批系统

以下是一个经典的责任链模式示例，演示如何用责任链处理不同级别的请假申请：

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

// 抽象处理者：管理者
class Manager {
protected:
    std::shared_ptr<Manager> nextManager;  // 指向下一个处理者

public:
    virtual ~Manager() = default;
    
    // 设置下一个处理者
    void setNextManager(std::shared_ptr<Manager> manager) {
        nextManager = manager;
    }
    
    // 处理请求的接口
    virtual void handleRequest(int days) const = 0;
};

// 具体处理者：主管
class Supervisor : public Manager {
public:
    void handleRequest(int days) const override {
        if (days <= 3) {
            std::cout << "Supervisor approved " << days << " days leave" << std::endl;
        } else if (nextManager) {
            nextManager->handleRequest(days);
        } else {
            std::cout << "Request for " << days << " days cannot be handled" << std::endl;
        }
    }
};

// 具体处理者：经理
class Manager : public Manager {
public:
    void handleRequest(int days) const override {
        if (days <= 10) {
            std::cout << "Manager approved " << days << " days leave" << std::endl;
        } else if (nextManager) {
            nextManager->handleRequest(days);
        } else {
            std::cout << "Request for " << days << " days cannot be handled" << std::endl;
        }
    }
};

// 具体处理者：总监
class Director : public Manager {
public:
    void handleRequest(int days) const override {
        if (days <= 30) {
            std::cout << "Director approved " << days << " days leave" << std::endl;
        } else {
            std::cout << "Request for " << days << " days requires CEO approval" << std::endl;
        }
    }
};

// 客户端代码
int main() {
    // 创建处理者
    auto supervisor = std::make_shared<Supervisor>();
    auto manager = std::make_shared<Manager>();
    auto director = std::make_shared<Director>();
    
    // 构建责任链
    supervisor->setNextManager(manager);
    manager->setNextManager(director);
    
    // 提交不同天数的请假申请
    supervisor->handleRequest(2);   // 主管处理
    supervisor->handleRequest(7);   // 经理处理
    supervisor->handleRequest(20);  // 总监处理
    supervisor->handleRequest(40);  // 超出处理范围
    
    return 0;
}

三、责任链模式的关键特性

请求处理者解耦：
- 客户端只需将请求发送给链头，无需知道具体由哪个处理者处理。
- 处理者之间通过引用连接，形成链式结构。
动态组合：
- 责任链可以在运行时动态构建和修改，灵活性高。
请求传递：
- 每个处理者可以选择处理请求或转发给下一个处理者。
- 链的末端可以是默认处理者或空处理者。

四、应用场景

多级审批系统：
- 如请假、报销、采购等需要多级审批的流程。
事件处理系统：
- GUI 框架中的事件冒泡机制（如点击事件从子控件向父控件传递）。
请求过滤：
- 网络请求的拦截器链（如身份验证、日志记录、数据压缩）。
异常处理：
- 异常捕获链，不同层级的处理者处理不同类型的异常。
游戏中的技能连招：
- 多个技能效果按顺序触发，每个效果可以选择继续或终止链。

五、责任链模式与其他设计模式的关系

装饰模式：
- 两者都使用链式结构，但责任链模式是为了让多个对象处理请求，而装饰模式是为了增强对象功能。
- 责任链的处理者可以选择终止链，而装饰模式的装饰器通常会继续调用下一个装饰器。
观察者模式：
- 责任链模式是单向传递请求，而观察者模式是一对多的事件通知。
- 责任链的处理者明确知道下一个处理者，而观察者模式的观察者不知道其他观察者的存在。
命令模式：
- 责任链模式可以处理命令，但命令模式更侧重于将请求封装为对象并支持撤销操作。

六、C++ 标准库中的责任链模式应用

异常处理机制：
- C++ 的 try-catch 块可以看作是一种责任链，异常会依次被各个 catch 块捕获和处理。
输入 / 输出流处理：
- 流操作符（如<<和>>）可以通过多个处理者（如格式化、过滤）传递数据。
STL 算法与迭代器：
- 某些算法（如std::for_each）可以结合函数对象链使用，形成处理流水线。

七、优缺点分析

优点：

降低耦合：请求发送者和接收者解耦，提高系统灵活性。
动态组合：可以在运行时动态调整处理者顺序和组成。
单一职责：每个处理者专注于自己的业务逻辑，符合单一职责原则。

缺点：

请求处理不确定性：客户端无法保证请求一定会被处理，可能需要在链尾添加默认处理者。
调试困难：链过长或处理者之间关系复杂时，调试和维护成本较高。
性能问题：如果链过长，请求传递可能会影响性能。

八、实战案例：Web 请求过滤器链

以下是一个 Web 请求过滤器链的实现示例：

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

// 请求类
class Request {
private:
    std::string url;
    std::string authToken;
    std::string payload;

public:
    Request(const std::string& u, const std::string& token, const std::string& data)
        : url(u), authToken(token), payload(data) {}
    
    std::string getUrl() const { return url; }
    std::string getAuthToken() const { return authToken; }
    std::string getPayload() const { return payload; }
    void setPayload(const std::string& data) { payload = data; }
};

// 抽象处理者：过滤器
class Filter {
protected:
    std::shared_ptr<Filter> nextFilter;

public:
    virtual ~Filter() = default;
    
    void setNextFilter(std::shared_ptr<Filter> filter) {
        nextFilter = filter;
    }
    
    // 处理请求的接口
    virtual bool process(const Request& request) const = 0;
};

// 具体处理者：身份验证过滤器
class AuthFilter : public Filter {
public:
    bool process(const Request& request) const override {
        std::cout << "AuthFilter: Checking authentication..." << std::endl;
        if (request.getAuthToken().empty()) {
            std::cout << "AuthFilter: Authentication failed" << std::endl;
            return false;
        }
        std::cout << "AuthFilter: Authentication passed" << std::endl;
        
        if (nextFilter) {
            return nextFilter->process(request);
        }
        return true;
    }
};

// 具体处理者：日志过滤器
class LogFilter : public Filter {
public:
    bool process(const Request& request) const override {
        std::cout << "LogFilter: Logging request - URL: " << request.getUrl() << std::endl;
        
        if (nextFilter) {
            return nextFilter->process(request);
        }
        return true;
    }
};

// 具体处理者：数据验证过滤器
class ValidationFilter : public Filter {
public:
    bool process(const Request& request) const override {
        std::cout << "ValidationFilter: Validating request data..." << std::endl;
        if (request.getPayload().size() > 1024) {
            std::cout << "ValidationFilter: Request data too large" << std::endl;
            return false;
        }
        std::cout << "ValidationFilter: Data validation passed" << std::endl;
        
        if (nextFilter) {
            return nextFilter->process(request);
        }
        return true;
    }
};

// 过滤器链管理器
class FilterChain {
private:
    std::shared_ptr<Filter> headFilter;

public:
    void addFilter(std::shared_ptr<Filter> filter) {
        if (!headFilter) {
            headFilter = filter;
        } else {
            std::shared_ptr<Filter> current = headFilter;
            while (current->nextFilter) {
                current = current->nextFilter;
            }
            current->setNextFilter(filter);
        }
    }
    
    bool processRequest(const Request& request) const {
        if (headFilter) {
            return headFilter->process(request);
        }
        return true;
    }
};

// 客户端代码
int main() {
    // 创建过滤器链
    FilterChain chain;
    chain.addFilter(std::make_shared<LogFilter>());
    chain.addFilter(std::make_shared<AuthFilter>());
    chain.addFilter(std::make_shared<ValidationFilter>());
    
    // 测试有效请求
    Request validRequest("/api/data", "token123", "payload");
    std::cout << "Processing valid request:" << std::endl;
    bool result = chain.processRequest(validRequest);
    std::cout << "Request processing result: " << (result ? "Success" : "Failure") << std::endl;
    
    std::cout << "\n";
    
    // 测试无效请求（无token）
    Request invalidRequest("/api/data", "", "payload");
    std::cout << "Processing invalid request:" << std::endl;
    result = chain.processRequest(invalidRequest);
    std::cout << "Request processing result: " << (result ? "Success" : "Failure") << std::endl;
    
    return 0;
}