设计模式笔记：责任链模式

责任链模式（Chain of Responsibility）是一种行为设计模式，它允许你将请求沿着处理者链进行传递。每个处理者都可以对请求进行处理，或者将请求传递给链中的下一个处理者。这个模式在处理多个对象都有机会处理请求时特别有用，并且不清楚哪个对象最终会处理请求时非常有效。

下面是一个简单的C++实现例子，其中定义了一个处理请求的抽象基类，以及几个具体的处理者类。每个处理者类都决定自己是否处理请求，或者将请求传递给下一个处理者。

#include <iostream>
#include <memory>

// 抽象处理者基类
class Handler {
public:
    virtual ~Handler() = default;

    // 设置下一个处理者
    void setNext(std::shared_ptr<Handler> nextHandler) {
        this->nextHandler = nextHandler;
    }

    // 处理请求的方法
    void handleRequest(int request) {
        if (canHandle(request)) {
            handle(request);
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        } else {
            std::cout << "No handler available for request: " << request << std::endl;
        }
    }

protected:
    // 判断当前处理者是否可以处理请求
    virtual bool canHandle(int request) const = 0;

    // 处理请求的具体操作
    virtual void handle(int request) const = 0;

private:
    std::shared_ptr<Handler> nextHandler;
};

// 具体的处理者类A
class ConcreteHandlerA : public Handler {
protected:
    bool canHandle(int request) const override {
        return request >= 0 && request < 10;
    }

    void handle(int request) const override {
        std::cout << "ConcreteHandlerA handled request: " << request << std::endl;
    }
};

// 具体的处理者类B
class ConcreteHandlerB : public Handler {
protected:
    bool canHandle(int request) const override {
        return request >= 10 && request < 20;
    }

    void handle(int request) const override {
        std::cout << "ConcreteHandlerB handled request: " << request << std::endl;
    }
};

// 具体的处理者类C
class ConcreteHandlerC : public Handler {
protected:
    bool canHandle(int request) const override {
        return request >= 20;
    }

    void handle(int request) const override {
        std::cout << "ConcreteHandlerC handled request: " << request << std::endl;
    }
};

int main() {
    // 创建处理者对象
    auto handlerA = std::make_shared<ConcreteHandlerA>();
    auto handlerB = std::make_shared<ConcreteHandlerB>();
    auto handlerC = std::make_shared<ConcreteHandlerC>();

    // 设置责任链
    handlerA->setNext(handlerB);
    handlerB->setNext(handlerC);

    // 发送请求
    handlerA->handleRequest(5);  // ConcreteHandlerA handled request: 5
    handlerA->handleRequest(15); // ConcreteHandlerB handled request: 15
    handlerA->handleRequest(25); // ConcreteHandlerC handled request: 25
    handlerA->handleRequest(30); // No handler available for request: 30

    return 0;
}

代码说明

1. Handler 类：

   • setNext(std::shared_ptr<Handler> nextHandler)：设置下一个处理者。
   • handleRequest(int request)：处理请求，根据 canHandle 的结果决定是否自己处理或传递给下一个处理者。
   • canHandle(int request) const 和 handle(int request) const：纯虚函数，需要在具体处理者类中实现。

2. ConcreteHandlerA, ConcreteHandlerB, ConcreteHandlerC 类：

   • 每个类都实现了 canHandle 和 handle 方法，用于判断和处理特定范围内的请求。

3. main 函数：

   • 创建处理者对象并设置责任链。
   • 发送不同的请求，观察责任链的处理结果。

这个简单的例子展示了责任链模式的基本思想和使用方法。根据实际需求，你可以扩展这个模式来处理更复杂的请求和处理逻辑。