Qt C++设计模式-＞责任链模式

多喝热水-多读书

于 2024-09-30 09:07:41 发布

阅读量480

点赞数 16

文章标签： c++ 设计模式责任链模式 qt

本文链接：https://blog.csdn.net/m0_46494667/article/details/142648656

版权

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象有机会处理请求，而不需要明确指定哪个对象处理。通过将这些对象连成一条链，请求沿着链传递，直到有对象处理它为止。该模式的主要目标是使请求的发送者与接收者解耦，且能够动态调整处理链。

责任链模式的应用场景

责任链模式适用于当有多个对象可以处理一个请求，但具体由哪个对象处理在运行时才能确定的情况。它可以避免发送者和处理者之间的紧耦合。常见的应用场景包括：

事件处理机制：例如GUI中的事件分发，某个控件未处理时，会传递给上层控件。
日志处理：日志请求可以通过不同的级别（如DEBUG、INFO、ERROR）进行处理，责任链可以动态调整处理链。

责任链模式的核心

处理者（Handler）：每个处理者对象都包含对下一个处理者的引用，请求从第一个处理者开始，沿着链条依次传递。
请求（Request）：可以是客户端发出的任何类型的请求，如事件、命令或任务。

每个处理者都有两个选择：

处理请求。
将请求传递给下一个处理者。

责任链模式示例代码

假设你正在开发一个简单的日志系统，日志可以按照不同的级别（例如DEBUG、INFO、ERROR）进行处理。不同的日志级别可能需要不同的处理方式。

#include <QDebug>
#include <QString>

// 抽象处理者类：定义日志处理接口
class Logger {
protected:
    Logger* next;  // 下一个处理者

public:
    Logger() : next(nullptr) {}

    void setNext(Logger* nextLogger) {
        next = nextLogger;  // 设置下一个处理者
    }

    // 处理日志请求的方法
    void logMessage(const QString& level, const QString& message) {
        if (canHandle(level)) {
            handle(message);  // 当前处理者可以处理该请求
        } else if (next) {
            next->logMessage(level, message);  // 传递给下一个处理者
        } else {
            qDebug() << "Unhandled log level:" << level;
        }
    }

    virtual ~Logger() = default;

protected:
    virtual bool canHandle(const QString& level) const = 0;  // 判断当前处理者是否能处理该请求
    virtual void handle(const QString& message) const = 0;    // 处理请求
};

// 具体处理者类：处理DEBUG级别的日志
class DebugLogger : public Logger {
protected:
    bool canHandle(const QString& level) const override {
        return level == "DEBUG";  // 处理DEBUG日志
    }

    void handle(const QString& message) const override {
        qDebug() << "[DEBUG]:" << message;
    }
};

// 具体处理者类：处理INFO级别的日志
class InfoLogger : public Logger {
protected:
    bool canHandle(const QString& level) const override {
        return level == "INFO";  // 处理INFO日志
    }

    void handle(const QString& message) const override {
        qDebug() << "[INFO]:" << message;
    }
};

// 具体处理者类：处理ERROR级别的日志
class ErrorLogger : public Logger {
protected:
    bool canHandle(const QString& level) const override {
        return level == "ERROR";  // 处理ERROR日志
    }

    void handle(const QString& message) const override {
        qDebug() << "[ERROR]:" << message;
    }
};

// 使用示例
int main() {
    // 创建具体处理者
    Logger* debugLogger = new DebugLogger();
    Logger* infoLogger = new InfoLogger();
    Logger* errorLogger = new ErrorLogger();

    // 设置责任链顺序：DEBUG -> INFO -> ERROR
    debugLogger->setNext(infoLogger);
    infoLogger->setNext(errorLogger);

    // 发送不同级别的日志请求
    debugLogger->logMessage("DEBUG", "This is a debug message.");
    debugLogger->logMessage("INFO", "This is an info message.");
    debugLogger->logMessage("ERROR", "This is an error message.");
    debugLogger->logMessage("TRACE", "This is a trace message.");  // 未处理的日志级别

    // 清理内存
    delete debugLogger;
    delete infoLogger;
    delete errorLogger;

    return 0;
}

代码解析

Logger类：抽象处理者类，定义了处理日志请求的接口，并包含指向下一个处理者的指针。logMessage方法判断是否由当前处理者处理请求，如果不能处理，则传递给下一个处理者。
DebugLogger、InfoLogger、ErrorLogger类：具体处理者类，分别处理不同级别的日志（DEBUG、INFO、ERROR）。每个类都重写了canHandle和handle方法，根据日志级别处理相应的请求。
客户端代码：客户端通过责任链发送不同级别的日志请求，链中的每个处理者依次判断是否处理该请求，未处理则传递给下一个处理者。