设计模式-职责链-C++

一、引言

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

二、使用场景

1. 处理请求的多种方式：当希望将请求的接收者动态地解耦，使得请求的发送者与接收者之间不直接连接时，职责链模式非常适用。

2. 请求者不关心处理者：当请求者只需知道一个对象且不关心谁真正处理请求，便可通过职责链简化代码。

3. 请求的处理者复杂：当需要多次选择和筛选请求的处理者时，职责链模式可以提高处理请求的灵活性。

4. 系统降低耦合度：对接收到的请求分别实现不同的请求处理方式，可以有效的做到系统解耦，便于后期扩展。

三、模式分类

• 简单职责链：通过简单的结构将请求按顺序传递给各处理者。

• 复杂职责链：扩展支持多层嵌套的处理逻辑，每个处理者可指向另一个负责接收的小链，适用于更复杂的业务逻辑。

四、优缺点

优点

• 降低耦合度：将请求者与处理者分离，便于修改，避免直接耦合对象的放松。
• 职责分配清晰：每个处理者只处理其特定的请求，使得各个处理者的责任明确。
• 增加或改变处理者方便：可以轻松增 添新的处理者，修改链中的处理逻辑，增强系统扩展性。

缺点

• 调试复杂：当请求在多个处理者之间传递时，调试复杂性增加，难以追踪请求处理的踪迹。
• 性能开销：请求可能在链中经过多次处理，彼此之间的接口调用会带来性能损耗。
• 不容易明确责任：在请求处理链较长时，可能使得责任模糊，很难快速得知问题出在哪里。

五、代码示例

以下是职责链模式的C++实现示例。

#include <iostream>
#include <memory>

// 抽象处理者类
class Handler {
protected:
    std::shared_ptr<Handler> next; // 下一个处理者

public:
    virtual ~Handler() = default;
    void setNext(std::shared_ptr<Handler> nextHandler) {
        next = nextHandler; // 设置下一个处理者
    }

    virtual void handleRequest(int request) = 0; // 抽象处理请求的方法
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 10) {
            std::cout << "Handler A handled request " << request << std::endl;
        } else if (next) {
            next->handleRequest(request); // 转递到下一个处理者
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 20) {
            std::cout << "Handler B handled request " << request << std::endl;
        } else if (next) {
            next->handleRequest(request); // 转递到下一个处理者
        }
    }
};

// 具体处理者C
class ConcreteHandlerC : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 30) {
            std::cout << "Handler C handled request " << request << std::endl;
        } else if (next) {
            next->handleRequest(request); // 转递到下一个处理者
        }
    }
};

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

    // 链接处理者
    handlerA->setNext(handlerB);
    handlerB->setNext(handlerC);

    // 客户端请求
    handlerA->handleRequest(5);   // Handler A 处理请求
    handlerA->handleRequest(15);  // Handler B 处理请求
    handlerA->handleRequest(25);  // Handler C 处理请求
    handlerA->handleRequest(35);  // 无人处理请求

    return 0;
}

代码解析

1. Handler 抽象类：定义了处理请求的接口，设置下一个处理者，并包含一个抽象方法 handleRequest()。

2. ConcreteHandlerA、ConcreteHandlerB 和 ConcreteHandlerC：具体处理者实现类，定义自身所接受的请求范围并在合适条件下处理请求，若无能力处理则转发至下一个处理者。

3. main() 函数：创建并链接多个处理者，客户端发出请求来请求处理，经过多个处理者递归处理请求。

六、模式总结

职责链模式用于为请求提供优雅的处理策略，将请求的发送者和接收者解耦。它能够极大地提升应用程序的灵活性与可扩展性，减少复杂性。虽然在使用中可能会面临调试局部性与性能等问题，但在适当的场合它仍然是一种非常有效的设计模式，通过合理组织职责分配，使得复杂应用的代码更加清晰，维护起来更为便利。