C++责任链模式与多级处理器应用

责任链模式通过将请求沿处理器链传递实现解耦，每个处理器可处理或转发请求，支持动态配置与多级流水线，如验证、日志、存储等环节灵活组合，提升系统扩展性与维护性。

在C++中，责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者链传递，直到某个处理器决定处理它。当系统需要支持多种处理逻辑，并且这些逻辑可能动态组合或顺序可变时，将责任链与多级处理器结合使用，可以实现灵活、解耦的处理流程。

责任链模式基本结构

责任链的核心是定义一个抽象处理器类，每个处理器持有下一个处理器的引用。请求从链首开始传递，每个处理器可以选择处理请求或将其转发给下一个节点。

示例代码：

class Handler {
public:
    virtual ~Handler() = default;
    virtual void setNext(Handler* next) { nextHandler = next; }
    virtual void handleRequest(const std::string& request) {
        if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
protected:
Handler* nextHandler = nullptr;
};
class ConcreteHandlerA : public Handler {
public:
void handleRequest(const std::string& request) override {
if (request == "A") {
std::cout << "Handler A processed the request.\n";
} else {
Handler::handleRequest(request);
}
}
};
class ConcreteHandlerB : public Handler {
public:
void handleRequest(const std::string& request) override {
if (request == "B") {
std::cout << "Handler B processed the request.\n";
} else {
Handler::handleRequest(request);
}
}
};

多级处理器的集成方式

在实际应用中，系统往往需要多个层级的处理步骤，例如日志系统中的格式化、过滤、输出等阶段。通过责任链串联不同类型的处理器，可以清晰划分职责。

例如构建一个消息处理流水线：

class ValidationHandler : public Handler {
public:
    void handleRequest(const Message& msg) override {
        if (!msg.isValid()) {
            std::cout << "Message rejected by validation.\n";
            return; // 终止传递
        }
        std::cout << "Validated message.\n";
        Handler::handleRequest(msg);
    }
};
class LoggingHandler : public Handler {
public:
void handleRequest(const Message& msg) override {
std::cout << "Logged message: " << msg.getId() << "\n";
Handler::handleRequest(msg);
}
};
class StorageHandler : public Handler {
public:
void handleRequest(const Message& msg) override {
saveToDatabase(msg);
std::cout << "Message stored.\n";
// 可能是链尾，无需继续传递
}
};

运行时动态配置处理链

利用责任链的优势，可以在程序运行时根据配置构造不同的处理流程。比如根据不同环境启用或跳过某些处理器。

构建示例：

Handler* buildProcessingChain(bool enableMonitoring) {
    auto* validator = new ValidationHandler();
    auto* logger = new LoggingHandler();
    auto* storage = new StorageHandler();
validator->setNext(logger);
logger->setNext(storage);

if (enableMonitoring) {
    auto* monitor = new MonitoringHandler();
    logger->setNext(monitor);
    monitor->setNext(storage);
}

return validator;
}

基本上就这些。这种结构让系统更易于维护和扩展，每个处理器独立变化，链的组织方式灵活，适合复杂业务流程的建模。关键在于明确每个处理器的职责边界，避免过度耦合。