责任链模式，它允许你将请求沿着处理者链传递，直到有一个处理者能够处理该请求为止。在责任链模式中，有三个核心角色：请求者（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);}// 具体处理者Astatic class ConcreteHandlerA implements Handler {private Handler successor;public void setSuccessor(Handler successor) {this.successor = successor;}@Overridepublic void handleRequest(Request request) {if (request.getContent().equals("A")) {System.out.println("ConcreteHandlerA is handling the request.");} else if (successor != null) {successor.handleRequest(request);}}}// 具体处理者Bstatic class ConcreteHandlerB implements Handler {private Handler successor;public void setSuccessor(Handler successor) {this.successor = successor;}@Overridepublic 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);}
}