一、什么是责任链模式

责任链模式是一种行为设计模式，它允许多个对象按照顺序处理请求，直到其中一个对象能够处理该请求为止。这些对象被组织成一个链，并且每个对象都有机会处理请求或者将其传递给链中的下一个对象。

二、责任链模式的实现原理

1. 定义抽象处理者（Handler）：创建一个抽象类或接口，定义处理请求的方法，并包含一个指向下一个处理者的引用。

2. 创建具体处理者（ConcreteHandler）：继承或实现抽象处理者，实现处理请求的方法。如果能够处理请求，则进行处理；否则将请求传递给下一个处理者。

3. 构建责任链：在客户端代码中，创建具体处理者的实例，并通过设置其下一个处理者的引用，形成一个责任链。

4. 发起请求：将请求发送给责任链的第一个处理者。处理者按照顺序尝试处理请求，直到有一个处理者能够处理成功。

5. 客户端代码与责任链解耦：客户端代码只需要知道第一个处理者，并将请求发送给它，无需关心具体的处理者是谁以及如何处理请求。

总之：责任链模式就是通过将多个处理者组成一个链条，每个处理者都有机会处理请求，直到有一个处理者能够成功处理为止。这样可以实现请求的动态分配和解耦，提高代码的灵活性和可维护性。

三、责任链模式的应用场景

• 请求的处理顺序不确定：当一个请求需要按照一定的顺序经过多个处理者进行处理时，可以使用责任链模式。每个处理者都有机会处理请求，直到有一个处理者能够处理该请求或者请求到达链的末尾。

• 请求的处理者动态变化：责任链模式可以动态地组织和调整处理者的顺序和数量。新的处理者可以随时加入到链中，或者从链中移除，从而灵活地改变请求的处理流程。

• 解耦请求发送者和接收者：责任链模式将请求发送者和接收者解耦，使得发送者无需知道具体的接收者是谁，只需要将请求发送给第一个处理者即可。这样可以降低系统的耦合度，提高系统的灵活性和可扩展性。

• 多个对象可以处理同一请求：责任链模式允许多个对象都有机会处理同一个请求，但每个请求只能由一个对象来处理。这样可以避免请求的发送者与接收者之间的紧耦合关系，提高代码的可维护性和可扩展性。

• 需要动态指定处理者：责任链模式可以根据实际情况动态地指定请求的处理者。根据请求的类型、内容或者其他条件，可以灵活地选择合适的处理者来处理请求。

四、责任链模式的代码实现

//+------------------------------------------------------------------+
//| structure                                                        |
//+------------------------------------------------------------------+
//
//                                        +----------------+
//                                        |                |
//                                        v     successor  |
//      |Client|------------>|    Handler    |-------------+
//                           |---------------|
//                           |HandleRequest()|
//                                   ^
//                                   |
//                      +------------+-------------+
//                      |                          |
//             |ConcreteHandler1|         |ConcreteHandler2|
//             |----------------|         |----------------|
//             |HandleRequest() |         |HandleRequest() |
//
interface ClientInterface //pattern client
{
    string Output(void); //returns header
    void Run(void); //execute the pattern client
};
//
void Run(ClientInterface* client) //launches a pattern
{
    printf("---\n%s",client.Output()); //print pattern header
    client.Run(); //execute client collaborations
    delete client; //exit
}
// 定义用于处理请求的接口
//（可选）实现后续链接
class Handler
{
    public:
        Handler*          successor;
        virtual void      HandleRequest(int)=0;
        ~Handler(void);
};
//
Handler::~Handler(void)
{
    delete successor;
}
//
class ConcreteHandler1:public Handler
{
    public:
        void              HandleRequest(int);
};
//
void ConcreteHandler1::HandleRequest(int request)
{
    if (request == 1)
        Print("request: ",request,". response: one. handled by: ",&this);
    else
    {
        if (CheckPointer(successor))
        {
            Print("request: ",request,". cannot be handled by ",&this,", forwarding to successor...");
            successor.HandleRequest(request);
        }
    }
}
//
class ConcreteHandler2:public Handler
{
    public:
        void              HandleRequest(int);
};
//
void ConcreteHandler2::HandleRequest(int request)
{
    if (request == 2)
        Print("request: ",request,". response: two. handled by: ",&this);
    else
    {
        if(CheckPointer(successor))
        {
            Print("request: ",request,". cannot be handled by ",&this,", forwarding to successor...");
            successor.HandleRequest(request);
        }
    }
}
// 向责任链上的具体处理程序发起请求
class Client:public ClientInterface
{
    public:
        string            Output();
        void              Run();
};
string Client::Output()
{
    return __FUNCTION__;
}
// 请求沿着链发送，直到具体的处理程序处理它为
void Client::Run()
{
    Handler* h1 = new ConcreteHandler1();
    Handler* h2 = new ConcreteHandler2();
    h1.successor = h2;
    h1.HandleRequest(1); // will handle the request
    h1.HandleRequest(2); // will pass the request to successor
    delete h1;
}
//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
void OnStart() 
{
    Run(new Client);
}
//+------------------------------------------------------------------+
//| output                                                           |
//+------------------------------------------------------------------+
//   ChainOfResponsibility::Client::Output
//   request: 1. response: one. handled by: 2097152
//   request: 2. cannot be handled by 2097152, forwarding to successor...
//   request: 2. response: two. handled by: 3145728