【设计模式】深入理解责任链模式的工作原理，责任链模式的多重应用场景：从权限管理到审批流程，在日志记录系统中的应用，在网络中实现动态请求处理

于 2024-01-18 20:28:31 发布
阅读量1.2k 收藏 19
点赞数 32
分类专栏： C++随想录 文章标签： 算法 责任链模式 设计模式 c++ 网络 码蚁软件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mars1199/article/details/135683296
版权

前言：

责任链模式是一种行为设计模式，用于将请求的发送者和接收者解耦。在这种模式中，请求通过一条由多个对象组成的链传递，直到有一个对象能够处理该请求为止。每个对象都可以决定是否处理请求以及是否将请求传递给下一个对象。

这种模式非常适合处理多个对象可能会处理同一个请求的情况，或者在运行时确定哪个对象将处理请求。责任链模式可以动态地组织对象之间的关系，从而更灵活地处理请求。

在责任链模式中，通常会建立一个抽象处理者（Handler）类，定义一个处理请求的方法，以及一个指向下一个处理者的引用。具体的处理者类继承自抽象处理者类，根据自身能力决定是否处理请求以及如何处理请求。

责任链模式可以帮助我们避免将请求的发送者与接收者耦合在一起，同时提供了更大的灵活性和可扩展性，使得系统更易于维护和扩展。

一、原理和示例代码：

责任链模式的原理是将请求的发送者和接收者解耦，通过一条由多个对象组成的链传递请求，直到有一个对象能够处理该请求为止。每个对象都可以决定是否处理请求以及是否将请求传递给下一个对象。这种模式可以动态地组织对象之间的关系，从而更灵活地处理请求。

以下是一个简单的 C++ 示例代码，演示了责任链模式的实现：

#include <iostream>
#include <string>

// 抽象处理者
class Handler {
public:
    virtual void handleRequest(const std::string& request) = 0;
    virtual void setNextHandler(Handler* handler) = 0;
};

// 具体处理者 A
class ConcreteHandlerA : public Handler {
private:
    Handler* nextHandler;

public:
    void handleRequest(const std::string& request) override {
        if (request == "A") {
            std::cout << "ConcreteHandlerA handles the request." << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
    }

    void setNextHandler(Handler* handler) override {
        nextHandler = handler;
    }
};

// 具体处理者 B
class ConcreteHandlerB : public Handler {
private:
    Handler* nextHandler;

public:
    void handleRequest(const std::string& request) override {
        if (request == "B") {
            std::cout << "ConcreteHandlerB handles the request." << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
    }

    void setNextHandler(Handler* handler) override {
        nextHandler = handler;
    }
};

int main() {
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();

    handlerA->setNextHandler(handlerB);

    handlerA->handleRequest("A");
    handlerA->handleRequest("B");
    handlerA->handleRequest("C");

    delete handlerA;
    delete handlerB;

    return 0;
}

在这个示例中，我们定义了抽象处理者类 Handler，以及两个具体处理者类 ConcreteHandlerA 和 ConcreteHandlerB。每个具体处理者类都可以处理特定的请求，并决定是否将请求传递给下一个处理者。在 main 函数中，我们创建了两个具体处理者对象，并将它们组织成责任链。通过调用 handleRequest 方法，我们可以看到责任链模式的工作原理。

二、结构图

责任链模式的结构图通常包括以下几个要素：

  1. Handler（处理者）：定义一个处理请求的接口，并维护一个指向下一个处理者的引用。
  2. ConcreteHandler（具体处理者）：实现处理请求的接口，并决定是否处理请求以及是否将请求传递给下一个处理者。
  3. Client（客户端）：创建责任链，并向链中的第一个处理者发送请求。

责任链模式的结构图通常是一个链状结构，其中每个处理者对象都包含一个指向下一个处理者的引用。请求从链的顶部开始，依次经过每个处理者，直到有一个处理者能够处理该请求或者请求到达链的末尾。

下面是责任链模式的简化结构图：

  +---------------------+        +---------------------+
  |      Handler        |        |   ConcreteHandler   |
  +---------------------+        +---------------------+
  | +handleRequest()    |        | +handleRequest()    |
  | +setNextHandler()   |------->| +setNextHandler()   |
  +---------------------+        +---------------------+
                |
                |
                V
  +---------------------+
  |       Client        |
  +---------------------+
  |                     |
  +---------------------+

在这个结构图中，Handler 定义了处理请求的接口和指向下一个处理者的引用，ConcreteHandler 实现了处理请求的接口，并决定是否将请求传递给下一个处理者。Client 负责创建责任链并向链的第一个处理者发送请求。

责任链模式的结构图清晰地展示了责任链中各个对象的关系，以及请求在责任链中的传递方式。

三、使用场景

责任链模式通常在以下场景中使用：

  1. 处理请求的对象可能不确定：当请求的处理对象需要动态确定时，可以使用责任链模式。责任链模式允许请求在链中传递，直到有一个处理者能够处理该请求。

  2. 需要避免发送者和接收者之间的耦合：责任链模式可以将发送者和接收者解耦，发送者不需要知道具体的接收者是谁，只需要将请求发送给责任链的第一个处理者即可。

  3. 处理请求的对象集合需要动态组合：责任链模式允许动态地组织处理请求的对象集合，可以根据需要灵活地添加、删除或修改处理者，而不影响客户端的代码。

  4. 处理请求的对象需要按顺序执行：如果需要按照一定的顺序依次执行处理者来处理请求，责任链模式是一个很好的选择。

  5. 需要对请求的发送者和接收者进行解耦：责任链模式可以帮助发送者和接收者之间的解耦，发送者只需要将请求发送给责任链的第一个处理者，而不需要知道请求最终由谁来处理。

总的来说，责任链模式适用于需要动态组织对象处理请求、需要解耦发送者和接收者、以及需要按顺序执行处理者来处理请求的场景。

常见具体场景：

1、

一个典型的例子是请假审批流程。假设一个公司有不同级别的主管，员工需要请假时，申请会依次传递给各级主管进行审批，直到有一个主管批准为止。下面我们通过一个简单的 C++ 示例来演示责任链模式在请假审批中的应用。

#include <iostream>
#include <string>

// 申请类
class LeaveRequest {
public:
    std::string name;
    int days;
    LeaveRequest(const std::string& n, int d) : name(n), days(d) {}
};

// 抽象处理者
class Approver {
protected:
    Approver* successor; // 后继者
public:
    void setSuccessor(Approver* successor) {
        this->successor = successor;
    }
    virtual void processRequest(const LeaveRequest& request) = 0;
};

// 具体处理者A
class Supervisor : public Approver {
public:
    void processRequest(const LeaveRequest& request) override {
        if (request.days <= 2) {
            std::cout << "Supervisor approved the leave for " << request.name << std::endl;
        } else if (successor != nullptr) {
            successor->processRequest(request);
        }
    }
};

// 具体处理者B
class Manager : public Approver {
public:
    void processRequest(const LeaveRequest& request) override {
        if (request.days <= 5) {
            std::cout << "Manager approved the leave for " << request.name << std::endl;
        } else if (successor != nullptr) {
            successor->processRequest(request);
        }
    }
};

// 具体处理者C
class Director : public Approver {
public:
    void processRequest(const LeaveRequest& request) override {
        if (request.days <= 10) {
            std::cout << "Director approved the leave for " << request.name << std::endl;
        } else {
            std::cout << "Leave request for " << request.name << " is rejected" << std::endl;
        }
    }
};

int main() {
    // 创建具体处理者对象
    Supervisor supervisor;
    Manager manager;
    Director director;

    // 构建责任链
    supervisor.setSuccessor(&manager);
    manager.setSuccessor(&director);

    // 发起请假申请
    LeaveRequest request1("Alice", 3);
    supervisor.processRequest(request1);

    LeaveRequest request2("Bob", 7);
    supervisor.processRequest(request2);

    LeaveRequest request3("Eve", 12);
    supervisor.processRequest(request3);

    return 0;
}

在这个示例中，我们定义了一个请假申请类 LeaveRequest，以及抽象处理者类 Approver 和三个具体处理者类 Supervisor、Manager 和 Director。在 main 函数中，我们创建了具体处理者对象，并将它们组织成责任链。通过调用 processRequest 方法，我们模拟了员工发起请假申请并经过责任链进行审批的过程。

当我们运行这个示例时，可以看到不同级别的主管根据请假天数依次进行审批，直到有一个主管批准或拒绝为止。这展示了责任链模式在请假审批流程中的应用。

 2、

在软件中实现日志记录器。假设我们有一个日志记录器，它可以根据日志级别将日志信息输出到不同的目标，比如控制台、文件、数据库等。我们可以使用责任链模式来实现这样的日志记录器，让每个日志目标作为责任链中的一个处理者，根据日志级别来决定是否处理该日志以及如何处理。

下面是一个简单的 C++ 示例，演示了如何使用责任链模式实现日志记录器：

#include <iostream>
#include <string>

// 日志级别枚举
enum class LogLevel {
    Info,
    Warning,
    Error
};

// 日志信息类
class LogMessage {
public:
    std::string message;
    LogLevel level;
    LogMessage(const std::string& msg, LogLevel lvl) : message(msg), level(lvl) {}
};

// 抽象处理者
class Logger {
protected:
    Logger* successor; // 后继者
public:
    void setSuccessor(Logger* successor) {
        this->successor = successor;
    }
    virtual void logMessage(const LogMessage& message) = 0;
};

// 控制台日志处理者
class ConsoleLogger : public Logger {
public:
    void logMessage(const LogMessage& message) override {
        if (message.level == LogLevel::Info) {
            std::cout << "Console log (Info): " << message.message << std::endl;
        } else if (successor != nullptr) {
            successor->logMessage(message);
        }
    }
};

// 文件日志处理者
class FileLogger : public Logger {
public:
    void logMessage(const LogMessage& message) override {
        if (message.level == LogLevel::Warning) {
            std::cout << "File log (Warning): " << message.message << std::endl;
        } else if (successor != nullptr) {
            successor->logMessage(message);
        }
    }
};

// 数据库日志处理者
class DatabaseLogger : public Logger {
public:
    void logMessage(const LogMessage& message) override {
        if (message.level == LogLevel::Error) {
            std::cout << "Database log (Error): " << message.message << std::endl;
        } else {
            std::cout << "No suitable logger found for the message" << std::endl;
        }
    }
};

int main() {
    // 创建具体处理者对象
    ConsoleLogger consoleLogger;
    FileLogger fileLogger;
    DatabaseLogger databaseLogger;

    // 构建责任链
    consoleLogger.setSuccessor(&fileLogger);
    fileLogger.setSuccessor(&databaseLogger);

    // 发起日志记录
    LogMessage message1("This is an info message", LogLevel::Info);
    consoleLogger.logMessage(message1);

    LogMessage message2("This is a warning message", LogLevel::Warning);
    consoleLogger.logMessage(message2);

    LogMessage message3("This is an error message", LogLevel::Error);
    consoleLogger.logMessage(message3);

    return 0;
}

在这个示例中，我们定义了一个日志信息类 LogMessage，以及抽象处理者类 Logger 和三个具体处理者类 ConsoleLogger、FileLogger 和 DatabaseLogger。在 main 函数中，我们创建了具体处理者对象，并将它们组织成责任链。通过调用 logMessage 方法，我们模拟了不同级别的日志信息经过责任链进行处理的过程。

当我们运行这个示例时，可以看到不同级别的日志信息根据其级别依次被不同的日志处理者处理，直到找到合适的处理者为止。这展示了责任链模式在日志记录器中的应用。

3、

在图形用户界面（GUI）应用程序中处理用户输入事件。假设我们有一个复杂的 GUI 应用程序，用户可以在不同的窗口、控件或组件中进行交互操作，比如点击按钮、输入文本等。我们可以使用责任链模式来处理用户输入事件，让每个窗口、控件或组件作为责任链中的一个处理者，根据事件类型和位置来决定是否处理该事件以及如何处理。

下面是一个简单的 C++ 示例，演示了如何使用责任链模式处理用户输入事件：

#include <iostream>
#include <string>

// 用户输入事件类
class UserInputEvent {
public:
    std::string eventType;
    int x, y; // 事件发生的位置
    UserInputEvent(const std::string& type, int x, int y) : eventType(type), x(x), y(y) {}
};

// 抽象处理者
class UIComponent {
protected:
    UIComponent* successor; // 后继者
public:
    void setSuccessor(UIComponent* successor) {
        this->successor = successor;
    }
    virtual void handleInputEvent(const UserInputEvent& event) = 0;
};

// 窗口类
class UIWindow : public UIComponent {
public:
    void handleInputEvent(const UserInputEvent& event) override {
        if (event.eventType == "MouseClick" && event.x >= 100 && event.y >= 100) {
            std::cout << "Window clicked at position (" << event.x << ", " << event.y << ")" << std::endl;
        } else if (successor != nullptr) {
            successor->handleInputEvent(event);
        }
    }
};

// 按钮类
class UIButton : public UIComponent {
public:
    void handleInputEvent(const UserInputEvent& event) override {
        if (event.eventType == "MouseClick" && event.x >= 50 && event.y >= 50) {
            std::cout << "Button clicked at position (" << event.x << ", " << event.y << ")" << std::endl;
        } else if (successor != nullptr) {
            successor->handleInputEvent(event);
        }
    }
};

int main() {
    // 创建具体处理者对象
    UIWindow window;
    UIButton button;

    // 构建责任链
    window.setSuccessor(&button);

    // 模拟用户输入事件
    UserInputEvent clickEvent("MouseClick", 120, 120);
    window.handleInputEvent(clickEvent);

    UserInputEvent clickEvent2("MouseClick", 60, 60);
    window.handleInputEvent(clickEvent2);

    return 0;
}

在这个示例中，我们定义了一个用户输入事件类 UserInputEvent，以及抽象处理者类 UIComponent 和两个具体处理者类 UIWindow 和 UIButton。在 main 函数中，我们创建了具体处理者对象，并将它们组织成责任链。通过调用 handleInputEvent 方法，我们模拟了用户点击事件在责任链中的处理过程。

当我们运行这个示例时，可以看到用户点击事件根据事件类型和位置依次被不同的 UI 组件处理，直到找到合适的处理者为止。这展示了责任链模式在处理用户输入事件的 GUI 应用程序中的应用。

4、

在网络请求处理中。假设我们有一个网络服务器，它接收来自客户端的各种请求，比如 HTTP 请求、WebSocket 请求等。我们可以使用责任链模式来处理这些请求，让每个处理者负责处理特定类型的请求，并且可以根据需要将请求传递给下一个处理者。

下面是一个简单的 C++ 示例，演示了如何使用责任链模式处理网络请求：

#include <iostream>
#include <string>

// 请求类
class Request {
public:
    std::string type;
    std::string content;
    Request(const std::string& type, const std::string& content) : type(type), content(content) {}
};

// 抽象处理者
class RequestHandler {
protected:
    RequestHandler* successor; // 后继者
public:
    void setSuccessor(RequestHandler* successor) {
        this->successor = successor;
    }
    virtual void handleRequest(const Request& request) = 0;
};

// HTTP 请求处理者
class HttpRequestHandler : public RequestHandler {
public:
    void handleRequest(const Request& request) override {
        if (request.type == "HTTP") {
            std::cout << "Handling HTTP request with content: " << request.content << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

// WebSocket 请求处理者
class WebSocketRequestHandler : public RequestHandler {
public:
    void handleRequest(const Request& request) override {
        if (request.type == "WebSocket") {
            std::cout << "Handling WebSocket request with content: " << request.content << std::endl;
        } else if (successor != nullptr) {
            successor->handleRequest(request);
        }
    }
};

int main() {
    // 创建具体处理者对象
    HttpRequestHandler httpRequestHandler;
    WebSocketRequestHandler webSocketRequestHandler;

    // 构建责任链
    httpRequestHandler.setSuccessor(&webSocketRequestHandler);

    // 模拟处理请求
    Request httpReq("HTTP", "Hello from HTTP request");
    httpRequestHandler.handleRequest(httpReq);

    Request wsReq("WebSocket", "Hello from WebSocket request");
    httpRequestHandler.handleRequest(wsReq);

    return 0;
}

在这个示例中，我们定义了一个请求类 Request，以及抽象处理者类 RequestHandler 和两个具体处理者类 HttpRequestHandler 和 WebSocketRequestHandler。在 main 函数中，我们创建了具体处理者对象，并将它们组织成责任链。通过调用 handleRequest 方法，我们模拟了不同类型的网络请求在责任链中的处理过程。

当我们运行这个示例时，可以看到不同类型的网络请求根据其类型依次被不同的请求处理者处理，直到找到合适的处理者为止。这展示了责任链模式在网络请求处理中的应用。

四、优缺点

责任链模式有以下优点：

  1. 解耦责任链的发送者和接收者：发送者无需知道链中的具体处理者，只需将请求发送给第一个处理者，由责任链自行决定最终的处理者。
  2. 灵活性和可扩展性：可以动态地增加或修改处理者，而不会影响客户端代码。
  3. 支持动态组合：可以动态地组合和拆解处理者，以满足不同的需求。
  4. 降低耦合度：责任链模式将请求的发送者和接收者解耦，使得系统更易于维护和扩展。

责任链模式也有一些缺点：

  1. 请求可能无法得到处理：如果责任链没有正确配置或者没有合适的处理者，请求可能会到达责任链的末端而得不到处理。
  2. 对性能的影响：责任链模式可能导致请求被多个处理者依次处理，可能会对性能产生一些影响。
  3. 可能导致系统变得复杂：责任链模式可能会导致系统中存在大量的细小对象，增加系统的复杂性。

在使用责任链模式时，需要根据具体的场景权衡其优缺点，以确保能够有效地满足系统的需求。

五、常见面试问题

以下是一些可能的面试问题以及针对这些问题的答案解析：

  1. 问题：请解释责任链模式及其作用。 答案解析：责任链模式是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。当一个请求被发送时，它会沿着责任链依次传递，直到有一个处理者处理它为止。

  2. 问题：责任链模式和装饰者模式有何区别？ 答案解析：责任链模式和装饰者模式都是行为设计模式，但它们的目的和应用场景不同。责任链模式用于处理请求的传递和处理，而装饰者模式用于动态地添加对象的功能。

  3. 问题：责任链模式在实际开发中的应用场景有哪些？ 答案解析：责任链模式在实际开发中常用于日志记录系统、权限管理系统、审批流程等场景，以及任何需要动态处理请求的场景。

  4. 问题：责任链模式的优缺点是什么？ 答案解析：责任链模式的优点包括解耦责任链的发送者和接收者、灵活性和可扩展性、支持动态组合和降低耦合度。缺点包括请求可能无法得到处理、对性能的影响和可能导致系统变得复杂。

  5. 问题：责任链模式和观察者模式有何区别？ 答案解析：责任链模式和观察者模式都是行为设计模式，但它们的作用和实现方式不同。责任链模式用于处理请求的传递和处理，而观察者模式用于对象之间的一对多依赖关系。

  6. 问题：请举例说明责任链模式在实际项目中的应用。 答案解析：可以举例说明责任链模式在日志记录系统、权限管理系统、审批流程等实际项目中的应用，以及如何通过责任链模式实现请求的处理和传递。

  7. 问题：责任链模式和状态模式有何区别？ 答案解析：责任链模式和状态模式都是行为设计模式，但它们的作用和实现方式不同。责任链模式用于处理请求的传递和处理，而状态模式用于对象的状态管理和转换。

  8. 问题：责任链模式和策略模式有何区别？ 答案解析：责任链模式和策略模式都是行为设计模式，但它们的作用和实现方式不同。责任链模式用于处理请求的传递和处理，而策略模式用于动态地选择算法。

  9. 问题：责任链模式如何避免请求的发送者和接收者之间的耦合关系？ 答案解析：责任链模式通过将请求的发送者和接收者解耦，允许多个对象都有机会处理请求，并且可以动态地增加或修改处理者，从而避免耦合关系。

  10. 问题：责任链模式在系统中的角色有哪些？ 答案解析：责任链模式中通常包括请求类（Request）、抽象处理者类（Handler）、具体处理者类（ConcreteHandler）等角色。

有什么想法也可以在评论区留言探讨，还可以到下方交流 👇👇👇 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

五木大大

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值