C++ 设计模式：职责链模式（Chain of Responsibility）

链接：C++ 设计模式
链接：C++ 设计模式 - 组合模式
链接：C++ 设计模式 - 迭代器模式

职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。这些对象通过形成一条链来传递请求，直到有一个对象处理它为止。

1. 问题分析

在开发中，我们经常遇到需要将请求发送给多个处理对象的情况。传统的做法是将所有处理逻辑集中在一个对象中，这样会导致代码复杂且难以维护。

职责链模式通过将请求的处理职责分散到多个对象中，每个对象都包含对下一个对象的引用，从而形成一条链。请求沿着这条链传递，直到有一个对象处理它为止。

2.实现步骤

1. 定义处理者接口（Handler）：声明处理请求的方法，并包含对下一个处理者的引用。
2. 实现具体处理者类（ConcreteHandler）：实现处理者接口，处理它所负责的请求，或将请求传递给下一个处理者。
3. 客户端代码（Client）：创建处理者链，并向链上的处理者对象提交请求。

3.代码示例

3.1.定义处理者接口

class Handler {
 public:
  virtual ~Handler() = default;
  void setNextHandler(Handler* next) { nextHandler_ = next; }
  virtual void handleRequest(const std::string& request) = 0;

 protected:
  Handler* nextHandler_ = nullptr;
};

3.2.实现具体处理者类

// 具体处理者类1
class ConcreteHandler1 : public Handler {
 public:
  void handleRequest(const std::string& request) override {
    if (request == "Low") {
      std::cout << "ConcreteHandler1 handled the request: " << request << std::endl;
    } else if (nextHandler_) {
      nextHandler_->handleRequest(request);
    }
  }
};

// 具体处理者类2
class ConcreteHandler2 : public Handler {
 public:
  void handleRequest(const std::string& request) override {
    if (request == "Medium") {
      std::cout << "ConcreteHandler2 handled the request: " << request << std::endl;
    } else if (nextHandler_) {
      nextHandler_->handleRequest(request);
    }
  }
};

// 具体处理者类3
class ConcreteHandler3 : public Handler {
 public:
  void handleRequest(const std::string& request) override {
    if (request == "High") {
      std::cout << "ConcreteHandler3 handled the request: " << request << std::endl;
    } else if (nextHandler_) {
      nextHandler_->handleRequest(request);
    }
  }
};

3.3.客户端代码

int main() {
  // 创建处理者对象
  ConcreteHandler1 handler1;
  ConcreteHandler2 handler2;
  ConcreteHandler3 handler3;

  // 设置处理者链
  handler1.setNextHandler(&handler2);
  handler2.setNextHandler(&handler3);

  // 提交请求
  handler1.handleRequest("Low");
  handler1.handleRequest("Medium");
  handler1.handleRequest("High");
  handler1.handleRequest("Unknown");

  return 0;
}

4.总结

1. 优点
   • 降低耦合度：请求的发送者和接收者解耦。
   • 增强灵活性：可以动态地添加或修改处理者链。
   • 责任分担：每个处理者只需处理自己负责的部分。
2. 缺点
   • 调试困难：由于请求的处理是沿链传递的，调试时可能需要跟踪多个处理者。
   • 性能问题：如果链条过长，可能会影响性能。