责任链模式,它允许你将请求沿着处理者链传递,直到有一个处理者能够处理该请求为止。在责任链模式中,有三个核心角色:请求者(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);}
}