C++设计模式——Chain of Responsibility职责链模式

一，职责链模式的定义

职责链模式，又被称为责任链模式，是一种行为型设计模式，它让多个对象依次处理收到的请求，直到处理完成为止。

职责链模式需要使用多个对象，其中的每个对象要么处理请求，要么将请求传递给下一个对象，该模式因此可以实现发送方与接收方的松散耦合。

在职责链模式中，一个对象可以被理解为处理器，每个处理器都包含对下一个处理器的引用，多个对象之间形成了一个链表的结构。

职责链模式在现实生活中的抽象实例：

审批流程：在流程中，当一个申请需要多级审批时，可以使用职责链模式。每一级审批者都是职责链的一部分。

银行账户验证：在银行系统中，需要对用户进行身份验证和授权操作，而验证操作涉及多个步骤。

异常处理：在程序开发中，每个异常处理器可以处理特定类型的异常，如果当前处理器无法解决，则传递给下一个处理器。

二，职责链模式的结构

职责链模式主要包含以下组件：

1.抽象处理器(Handler)：

处理器的抽象类，声明处理请求的抽象接口，并持有对下一个处理器的引用。

2.具体处理器(ConcreteHandler)：

继承自抽象处理器，包含了对处理请求接口的具体实现，负责处理特定类型的请求或将请求传递给下一个处理器。

3.客户端(Client)：

负责创建处理器的实例，并将它们加入到职责链中。然后向第一个处理器发送请求，并等待职责链的返回结果。

组件之间的工作步骤如下：

1.客户端将请求传递给职责链中的第一个处理器。

2.第一个处理器尝试处理请求。如果处理成功，则结束处理过程并返回结果，如果无法处理，则将请求转发给下一个处理器。

3.下一个处理器重复步骤2，直到找到能够处理请求的处理器，或者职责链中没有更多的处理器。

4.客户端获得处理结果。

对应UML类图：

三，职责链模式代码样例

#include <iostream>
#include <string>
class Handler
{
protected:
       Handler* successor;
public:
       void setSuccessor(Handler* successor)
       {
              this->successor = successor;
       }
       virtual void handleRequest(const std::string& request) = 0;
};
class ConcreteHandler1 : public Handler
{
public:
       void handleRequest(const std::string& request) override
       {
              if (request == "Type1")
              {
                      std::cout << "Handling request of type Type1." << std::endl;
              }
              else if (successor != nullptr)
              {
                      successor->handleRequest(request);
              }
              else
              {
                      std::cout << "Unable to handle the request." << std::endl;
              }
       }
};
class ConcreteHandler2 : public Handler
{
public:
       void handleRequest(const std::string& request) override
       {
              if (request == "Type2")
              {
                      std::cout << "Handling request of type Type2." << std::endl;
              }
              else if (successor != nullptr)
              {
                      successor->handleRequest(request);
              }
              else
              {
                      std::cout << "Unable to handle the request." << std::endl;
              }
       }
};
class ConcreteHandler3 : public Handler
{
public:
       void handleRequest(const std::string& request) override
       {
              if (request == "Type3")
              {
                      std::cout << "Handling request of type Type3." << std::endl;
              }
              else if (successor != nullptr)
              {
                      successor->handleRequest(request);
              }
              else
              {
                      std::cout << "Unable to handle the request." << std::endl;
              }
       }
};
int main()
{
       Handler* handler1 = new ConcreteHandler1();
       Handler* handler2 = new ConcreteHandler2();
       Handler* handler3 = new ConcreteHandler3();
       handler1->setSuccessor(handler2);
       handler2->setSuccessor(handler3);
       handler1->handleRequest("Type2");
       handler1->handleRequest("Type3");
       handler1->handleRequest("Type4");
       delete handler1;
       delete handler2;
       delete handler3;
       return 0;
}

运行结果：

Handling request of type Type2.
Handling request of type Type3.
Unable to handle the request.

四，职责链模式的应用场景

命令处理器：比如在游戏或GUI应用中，用户可以发送各种操作命令，如“播放音乐”、“关闭窗口”，而具体执行过程由一系列处理器完成。

日志记录器：将不同严重等级的日志交给不同的处理器去打印。

Web服务开发：在Web服务中，对请求进行校验和过滤，如权限验证、数据校验等。

权限控制：在用户权限管理中，可以根据角色的不同职责分配不同的权限验证步骤。

消息路由：在网络通信中，将不同类型的消息分别发送给不同的处理程序。

五，职责链模式的优缺点

职责链模式的优点：

和命令模式类似，可以实现发送者和接收者的解耦。

灵活性强，可以修改职责链中的结构和顺序。

有扩展性，可以在最小改动的情况下添加新的处理器。

处理器可以在不同的职责链中重复使用。

职责链模式的缺点：

对请求的处理可能覆盖不全，导致bug的产生。

请求的处理过程十分冗长。

请求的传递涉及多个对象，性能开销大。

责任链需要被一直维护和管理。

六，代码实战

Demo1：日志记录器

#include <iostream>
#include <string>
#include <vector>
//Logger接口
class Logger {
public:
    virtual void log(const std::string& message) = 0;
};
//处理正常日志
class InfoLogger: public Logger{
public:
    void log(const std::string& message) override {
        std::cerr << "Info: " << message << std::endl;
    }
};
//处理调试日志
class DebugLogger: public Logger{
public:
    void log(const std::string& message) override {
        std::cout << "Debug: " << message << std::endl;
    }
};
//处理错误日志
class ErrorLogger: public Logger{
public:
    void log(const std::string& message) override {
        std::cerr << "Error: " << message << std::endl;
    }
};
class LoggingChain {
private:
    std::vector<std::shared_ptr<Logger>> loggers;
public:
    void addLogger(std::shared_ptr<Logger> logger) {
        loggers.push_back(logger);
    }
    void log(const std::string& message) {
        for (auto it = loggers.rbegin(); it != loggers.rend(); ++it) {
            (*it)->log(message);
        }
    }
};
int main() {
    LoggingChain chain;
    chain.addLogger(std::make_shared<InfoLogger>());
    chain.addLogger(std::make_shared<DebugLogger>());
    chain.addLogger(std::make_shared<ErrorLogger>());
    chain.log("This is a test message.");
    return 0;
}

运行结果：

Error: This is a test message.
Debug: This is a test message.
Info: This is a test message.

Demo2：模拟消息接收

#include <iostream>
#include <string>
#include <vector>
class Message {
public:
    virtual ~Message() {}
};
class TextMessage : public Message {
};
class ImageMessage : public Message {
};
class MessageHandler{
public:
    virtual void handle(Message* msg) = 0;
};
class TextProcessor: public MessageHandler{
public:
    void handle(Message* msg) override{
        if (dynamic_cast<TextMessage*>(msg)) {
            std::cout << "handling a text message." << std::endl;
            process(*static_cast<TextMessage*>(msg));
        }
        else {
            forward(msg);
        }
    }
private:
    void process(TextMessage& msg) {
    }
    void forward(Message* msg) {
    }
};
class ImageProcessor: public MessageHandler{
public:
    void handle(Message* msg) override {
        if (dynamic_cast<ImageMessage*>(msg)) {
            std::cout << "handling an image message." << std::endl;
            process(*static_cast<ImageMessage*>(msg));
        }
        else {
            forward(msg);
        }
    }
private:
    void process(ImageMessage& img){
    }
    void forward(Message* msg){
    }
};
class ChainOfResponsibility {
public:
    void setHandler(MessageHandler* handler){
        current_ = handler;
    }
    void handle(Message* msg) {
        current_->handle(msg);
    }
private:
    MessageHandler* current_ = nullptr;
};
int main() {
    ChainOfResponsibility chain;
    TextProcessor txtProc;
    ImageProcessor imgProc;
    chain.setHandler(&txtProc);
    chain.handle(new TextMessage());
    chain.setHandler(&imgProc);
    chain.handle(new ImageMessage());
    return 0;
}

运行结果：

handling a text message.
handling an image message.

七，参考阅读

https://www.geeksforgeeks.org/chain-responsibility-design-pattern/

https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.htm

https://sourcemaking.com/design_patterns/chain_of_responsibility