责任链模式，它允许你将请求沿着处理者链传递，直到有一个处理者能够处理该请求为止。在责任链模式中，有三个核心角色：请求者（Client）、处理者（Handler）、以及具体处理者（ConcreteHandler）。
① 请求者（Client）：负责创建请求对象，并将其发送到处理者链中。
② 处理者（Handler）：定义一个处理请求的接口，并且持有下一个处理者的引用。
③ 具体处理者（ConcreteHandler）：实现处理请求的具体逻辑，如果自己无法处理该请求，则将请求传递给下一个处理者。
责任链模式的核心思想是将请求发送者与接收者解耦，让多个对象都有机会处理请求，从而避免了请求发送者与接收者之间的直接耦合关系。

1、场景设计

实现场景：构建一个责任链，责任链上有A、B两个节点，A能够处理A相关的事务，B在A之后，可处理B相关的事务。所有事务首先到A，再到B。

2、C++实现

`Request` 类表示一个请求，包含了请求的内容。`Handler` 是处理者接口，定义了一个纯虚的 `handleRequest()` 方法，以及一个设置下一个处理者的方法。`ConcreteHandlerA` 和 `ConcreteHandlerB` 是具体处理者，实现了处理请求的具体逻辑。在 `main()` 函数中，我们创建了两个具体处理者，将它们串成一个处理者链，并将请求发送给第一个处理者来处理。 

#include <iostream>
#include <string>

// 请求类
class Request {
    private:
        std::string content;

    public:
        Request(const std::string& c) : content(c) {}

        std::string getContent() const {
            return content;
        }
};

// 处理者接口
class Handler {
    private:
        Handler* successor;

    public:
        Handler() : successor(nullptr) {}

        void setSuccessor(Handler* s) {
            successor = s;
        }

        virtual void handleRequest(const Request& request) = 0;

    protected:
        void passToNext(const Request& request) {
            if (successor != nullptr) {
                successor->handleRequest(request);
            }
        }
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
    public:
        void handleRequest(const Request& request) override {
            if (request.getContent() == "A") {
                std::cout << "ConcreteHandlerA is handling the request." << std::endl;
            } else {
                passToNext(request);
            }
        }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
    public:
        void handleRequest(const Request& request) override {
            if (request.getContent() == "B") {
                std::cout << "ConcreteHandlerB is handling the request." << std::endl;
            } else {
                passToNext(request);
            }
        }
};

int main() {
    ConcreteHandlerA handlerA;
    ConcreteHandlerB handlerB;

    handlerA.setSuccessor(&handlerB);

    Request requestA("A");
    Request requestB("B");
    Request requestC("C");

    handlerA.handleRequest(requestA);
    handlerA.handleRequest(requestB);
    handlerA.handleRequest(requestC);

    return 0;
}

3、Java实现

`Request` 类表示一个请求，包含了请求的内容。`Handler` 是处理者接口，定义了一个处理请求的方法 `handleRequest()`。`ConcreteHandlerA` 和 `ConcreteHandlerB` 是具体处理者，实现了处理请求的具体逻辑，并在需要时将请求传递给下一个处理者。在 `main()` 方法中，我们创建了两个具体处理者，将它们串成一个处理者链，并将请求发送给第一个处理者来处理。 

package behavioralpattern.chain;

public class ChainOfResponsibilityDemo {
    // 请求类
    static class Request {
        private String content;
        public Request(String content) {
            this.content = content;
        }
        public String getContent() {
            return content;
        }
    }
    // 处理者接口
    interface Handler {
        void handleRequest(Request request);
    }
    // 具体处理者A
    static class ConcreteHandlerA implements Handler {
        private Handler successor;
        public void setSuccessor(Handler successor) {
            this.successor = successor;
        }
        @Override
        public void handleRequest(Request request) {
            if (request.getContent().equals("A")) {
                System.out.println("ConcreteHandlerA is handling the request.");
            } else if (successor != null) {
                successor.handleRequest(request);
            }
        }
    }
    // 具体处理者B
    static class ConcreteHandlerB implements Handler {
        private Handler successor;
        public void setSuccessor(Handler successor) {
            this.successor = successor;
        }
        @Override
        public void handleRequest(Request request) {
            if (request.getContent().equals("B")) {
                System.out.println("ConcreteHandlerB is handling the request.");
            } else if (successor != null) {
                successor.handleRequest(request);
            }
        }
    }

    public static void main(String[] args) {
        ConcreteHandlerA handlerA = new ConcreteHandlerA();
        ConcreteHandlerB handlerB = new ConcreteHandlerB();

        handlerA.setSuccessor(handlerB);

        Request requestA = new Request("A");
        Request requestB = new Request("B");
        Request requestC = new Request("C");

        handlerA.handleRequest(requestA);
        handlerA.handleRequest(requestB);
        handlerA.handleRequest(requestC);
    }
}