责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许你将请求沿着处理链进行传递，直到有一个处理者能够处理该请求。该模式将请求的发送者和接收者解耦，使多个对象都有机会处理该请求，而不是将请求的发送者与接收者紧密耦合在一起。

概念

责任链模式建立了一条处理请求的链，每个处理者都有机会处理请求，直到请求被成功处理或者到达链的末尾。请求会依次在链上传递，直到找到可以处理请求的处理者为止。

思想

责任链模式的核心思想是将请求的发送者和接收者解耦，使得多个对象都有机会处理请求。请求会依次经过链上的处理者，每个处理者根据自己的处理能力来决定是否处理请求，从而实现请求的传递和处理。

角色

1. Handler（处理者）：定义一个处理请求的接口，通常包含一个指向下一个处理者的引用。
2. ConcreteHandler（具体处理者）：实现处理请求的方法，如果自己能够处理请求，则进行处理；否则将请求传递给下一个处理者。
3. Client（客户端）：创建处理链并将请求发送给链中的第一个处理者。

优点

1. 解耦发送者和接收者：请求发送者不需要知道请求由哪个具体处理者处理，只需将请求发送给链的第一个处理者即可，接收者也不需要知道请求的发送者是谁。
2. 灵活性和可扩展性：可以动态地添加或修改处理者，灵活调整处理链的顺序或结构。
3. 可以处理请求的变动：新增、删除或重新排序处理者时，对客户端代码没有影响。

缺点

1. 无法保证请求被处理：如果整个处理链没有处理请求，请求可能会被忽略或者无法处理。
2. 可能导致性能问题：由于请求需要经过多个处理者，如果处理链过长或者处理者处理请求的时间过长，可能会影响整体性能。

类图

@startuml
class Client {
  +sendRequest()
}

class Handler {
  -nextHandler: Handler
  +setNextHandler(Handler)
  +handleRequest()
}

class ConcreteHandlerA {
  +handleRequest()
}

class ConcreteHandlerB {
  +handleRequest()
}

class ConcreteHandlerC {
  +handleRequest()
}

Client --> Handler
Handler "1" --> "0..1" Handler
Handler <|-- ConcreteHandlerA
Handler <|-- ConcreteHandlerB
Handler <|-- ConcreteHandlerC
@enduml

示例代码

以下是使用C++编写的示例代码：

#include <iostream>

// Handler（处理者）
class Handler {
protected:
    Handler* nextHandler;

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

    virtual void handleRequest(int request) = 0;
};

// ConcreteHandlerA（具体处理者A）
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "ConcreteHandlerA handles the request: " << request << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
    }
};

// ConcreteHandlerB（具体处理者B）
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandlerB handles the request: " << request << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
    }
};

// ConcreteHandlerC（具体处理者C）
class ConcreteHandlerC : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 20 && request < 30) {
            std::cout << "ConcreteHandlerC handles the request: " << request << std::endl;
        } else if (nextHandler != nullptr) {
            nextHandler->handleRequest(request);
        }
    }
};

int main() {
    // 创建处理者对象
    Handler* handlerA = new ConcreteHandlerA();
    Handler* handlerB = new ConcreteHandlerB();
    Handler* handlerC = new ConcreteHandlerC();

    // 构建处理链
    handlerA->setNextHandler(handlerB);
    handlerB->setNextHandler(handlerC);

    // 发送请求
    handlerA->handleRequest(5);
    handlerA->handleRequest(15);
    handlerA->handleRequest(25);

    // 释放资源
    delete handlerA;
    delete handlerB;
    delete handlerC;

    return 0;
}

运行结果：

ConcreteHandlerA handles the request: 5
ConcreteHandlerB handles the request: 15
ConcreteHandlerC handles the request: 25

以上示例代码中，定义了三个具体处理者（ConcreteHandlerA、ConcreteHandlerB、ConcreteHandlerC）和一个客户端（Client）。每个具体处理者负责处理一定范围的请求，如果自己无法处理请求，则将请求传递给下一个处理者。在客户端中创建处理者对象，并构建处理链，然后发送请求。根据处理链的设置，每个请求会依次经过处理者进行处理，直到找到能够处理请求的处理者为止。输出结果显示每个请求由相应的处理者处理。