C++职责链模式的设计思想与实际应用场景解析-源码库

C++职责链模式的设计思想与实际应用场景解析

作为一名在C++领域摸爬滚打多年的开发者，我深刻体会到设计模式在实际项目中的重要性。今天我想和大家深入聊聊职责链模式，这个在处理请求传递和业务逻辑解耦方面表现出色的设计模式。记得我第一次接触职责链模式是在处理一个复杂的审批系统时，当时if-else嵌套了七八层，代码维护起来简直是一场噩梦。

什么是职责链模式

职责链模式的核心思想是将请求的发送者和接收者解耦，让多个对象都有机会处理这个请求。这些对象连接成一条链，请求沿着这条链传递，直到有对象处理它为止。就像公司里的审批流程一样，一个请假申请可能从组长到经理再到总监，每个层级都有自己审批的权限范围。

在实际项目中，我发现职责链模式特别适合以下场景：

多个对象可以处理同一请求，但具体由哪个对象处理需要在运行时确定
需要在不明确指定接收者的情况下，向多个对象中的一个提交请求
可动态指定一组对象处理请求

职责链模式的基本结构

让我通过一个具体的代码示例来展示职责链模式的基本实现：


#include 
#include 
#include 

// 抽象处理者
class Handler {
public:
    virtual ~Handler() = default;
    
    void setNext(std::shared_ptr next) {
        nextHandler = next;
    }
    
    virtual void handleRequest(int request) {
        if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }

protected:
    std::shared_ptr nextHandler;
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request <= 10) {
            std::cout << "Handler A 处理请求: " << request << std::endl;
        } else {
            std::cout << "Handler A 无法处理，传递给下一个处理者" << std::endl;
            Handler::handleRequest(request);
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request > 10 && request <= 20) {
            std::cout << "Handler B 处理请求: " << request << std::endl;
        } else {
            std::cout << "Handler B 无法处理，传递给下一个处理者" << std::endl;
            Handler::handleRequest(request);
        }
    }
};

// 具体处理者C
class ConcreteHandlerC : public Handler {
public:
    void handleRequest(int request) override {
        if (request > 20 && request <= 30) {
            std::cout << "Handler C 处理请求: " << request << std::endl;
        } else {
            std::cout << "Handler C 无法处理，请求未被处理: " << request << std::endl;
        }
    }
};

实战案例：日志系统设计

让我分享一个在实际项目中应用职责链模式的真实案例。我们当时需要设计一个灵活的日志系统，要求能够根据日志级别自动路由到不同的处理方式。


#include 
#include 
#include 
#include 

enum LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR
};

class LogHandler {
public:
    virtual ~LogHandler() = default;
    
    void setNext(std::shared_ptr next) {
        nextHandler = next;
    }
    
    virtual void log(LogLevel level, const std::string& message) {
        if (nextHandler) {
            nextHandler->log(level, message);
        }
    }

protected:
    std::shared_ptr nextHandler;
};

class ConsoleHandler : public LogHandler {
public:
    void log(LogLevel level, const std::string& message) override {
        if (level >= INFO) {
            std::cout << "[CONSOLE] " << getLevelString(level) 
                      << ": " << message << std::endl;
        } else {
            LogHandler::log(level, message);
        }
    }

private:
    std::string getLevelString(LogLevel level) {
        switch(level) {
            case DEBUG: return "DEBUG";
            case INFO: return "INFO";
            case WARNING: return "WARNING";
            case ERROR: return "ERROR";
            default: return "UNKNOWN";
        }
    }
};

class FileHandler : public LogHandler {
public:
    void log(LogLevel level, const std::string& message) override {
        if (level >= WARNING) {
            // 模拟写入文件操作
            std::cout << "[FILE] " << getLevelString(level) 
                      << ": " << message << " (写入日志文件)" << std::endl;
        } else {
            LogHandler::log(level, message);
        }
    }

private:
    std::string getLevelString(LogLevel level) {
        switch(level) {
            case DEBUG: return "DEBUG";
            case INFO: return "INFO";
            case WARNING: return "WARNING";
            case ERROR: return "ERROR";
            default: return "UNKNOWN";
        }
    }
};

class EmailHandler : public LogHandler {
public:
    void log(LogLevel level, const std::string& message) override {
        if (level == ERROR) {
            std::cout << "[EMAIL] 发送错误告警邮件: " << message << std::endl;
        } else {
            LogHandler::log(level, message);
        }
    }
};

职责链模式的进阶技巧

在实际使用中，我总结了一些进阶技巧，这些都是在踩过不少坑之后才领悟到的：

1. 链的构建方式

我推荐使用建造者模式来构建职责链，这样代码更加清晰：


class HandlerChainBuilder {
private:
    std::shared_ptr first;
    std::shared_ptr current;

public:
    HandlerChainBuilder& addHandler(std::shared_ptr handler) {
        if (!first) {
            first = handler;
            current = handler;
        } else {
            current->setNext(handler);
            current = handler;
        }
        return *this;
    }
    
    std::shared_ptr build() {
        return first;
    }
};

2. 中断链的传递

有时候我们需要在处理完请求后中断链的传递，这时候可以在处理者中返回一个布尔值来表示是否继续传递：


class InterruptibleHandler {
public:
    virtual bool handleRequest(int request) = 0;
};

class ConcreteInterruptibleHandler : public InterruptibleHandler {
public:
    bool handleRequest(int request) override {
        if (canHandle(request)) {
            // 处理请求
            return true; // 中断传递
        }
        return false; // 继续传递
    }
    
private:
    bool canHandle(int request) {
        return request < 10;
    }
};