C++责任链模式 请求处理链实现

责任链模式通过链式结构将请求传递给多个处理器，实现解耦与灵活扩展。1. 定义抽象处理器基类Handler，包含处理请求方法和指向下一处理器的智能指针；2. 创建具体处理器LowLevelHandler、MidLevelHandler、HighLevelHandler，分别处理不同级别请求，若无法处理则转发给下一个；3. 在main函数中构建处理链，依次设置后继处理器；4. 发起请求由链头开始传递，根据请求级别被对应处理器处理或最终拒绝。该模式适用于日志分级、权限校验等场景，符合开闭原则，便于扩展新处理器而不影响现有逻辑。

在C++中，责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者链传递，直到某个对象处理它为止。这种模式解耦了请求的发送者和接收者，使得多个对象都有机会处理请求。

责任链模式的核心思想

定义一个处理请求的接口，并将多个处理器连接成一条链。请求在链上传递，每个处理器决定是处理请求还是将其传递给链中的下一个处理器。

典型应用场景包括：日志系统（不同级别日志由不同处理器处理）、权限校验、异常处理机制等。

实现步骤与代码示例

下面是一个简单的C++实现，展示如何构建一个请求处理链。

立即学习“C++免费学习笔记（深入）”；

// 抽象处理者类（Handler）

#include <iostream>
#include <memory>

class Request {
public:
    std::String type;
    int level;
    Request(const std::string& t, int l) : type(t), level(l) {}
};

class Handler {
public:
    virtual ~Handler() = default;
    virtual void handleRequest(const Request& request) = 0;
    void setNext(std::shared_ptr<Handler> next) {
        this->nextHandler = next;
    }
protected:
    std::shared_ptr<Handler> nextHandler = nullptr;
};

// 具体处理器：低级别处理器

class LowLevelHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level <= 1) {
            std::cout << “LowLevelHandler 处理请求: ” << request.type << std::endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};

// 具体处理器：中级处理器

class MidLevelHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level <= 2) {
            std::cout << “MidLevelHandler 处理请求: ” << request.type << std::endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};

// 具体处理器：高级别处理器

class HighLevelHandler : public Handler {
public:
    void handleRequest(const Request& request) override {
        if (request.level <= 3) {
            std::cout << “HighLevelHandler 处理请求: ” << request.type << std::endl;
        } else {
            std::cout << “无法处理该请求: ” << request.type << ” (级别过高)” << std::endl;
        }
    }
};

// 使用示例

int main() {
    auto low = std::make_shared<LowLevelHandler>();
    auto mid = std::make_shared<MidLevelHandler>();
    auto high = std::make_shared<HighLevelHandler>();

    low->setNext(mid);
    mid->setNext(high);

    Request req1(“bug修复”, 1);
    Request req2(“功能开发”, 2);
    Request req3(“架构设计”, 3);
    Request req4(“公司战略”, 4);

    low->handleRequest(req1);
    low->handleRequest(req2);
    low->handleRequest(req3);
    low->handleRequest(req4);

    return 0;
}

输出结果

LowLevelHandler 处理请求: bug修复
MidLevelHandler 处理请求: 功能开发
HighLevelHandler 处理请求: 架构设计
无法处理该请求: 公司战略 (级别过高)

关键点说明

每个处理器持有下一个处理器的引用，形成链式结构。
请求从链头开始传递，直到被处理或到达链尾。
使用 shared_ptr 管理生命周期，避免内存泄漏。
抽象基类定义接口，具体类实现各自逻辑，易于扩展。

基本上就这些。这种结构让系统更灵活，新增处理器不影响现有代码，符合开闭原则。