当前位置：首页 > news >正文

【设计模式】【行为型模式（Behavioral Patterns）】之责任链模式（Chain of Responsibility Pattern）

news 来源：原创 2025/7/19 3:36:04

1. 设计模式原理说明

责任链模式（Chain of Responsibility Pattern） 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。这样可以减少请求发送者和接收者之间的耦合。

主要角色

Handler（抽象处理者）：定义了一个处理请求的接口，通常包含一个后继连接，用于指向下一个处理者。
ConcreteHandler（具体处理者）：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
Client（客户端）：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

2. UML 类图及解释

UML 类图

+-----------------+
|    Handler      |
|-----------------|
| - successor: Handler |
| - setSuccessor(successor: Handler) |
| - handleRequest(request: Request) |
+-----------------+^||v
+-----------------+
| ConcreteHandlerA|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+^||v
+-----------------+
| ConcreteHandlerB|
|-----------------|
| - handleRequest(request: Request) |
+-----------------+

类图解释

Handler：定义了处理请求的接口，包含一个后继连接（successor），用于指向下一个处理者。
ConcreteHandlerA 和 ConcreteHandlerB：实现了处理请求的方法，判断是否处理该请求，如果不能处理则将请求转发给下一个处理者。
Client：创建处理者对象并组织成一条链，向链中的第一个处理者提交请求。

3. 代码案例及逻辑详解

Java 代码案例

// 抽象处理者
abstract class Handler {protected Handler successor;public void setSuccessor(Handler successor) {this.successor = successor;}public abstract void handleRequest(int request);
}// 具体处理者 A
class ConcreteHandlerA extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 0 && request < 10) {System.out.println("ConcreteHandlerA handled request " + request);} else if (successor != null) {successor.handleRequest(request);}}
}// 具体处理者 B
class ConcreteHandlerB extends Handler {@Overridepublic void handleRequest(int request) {if (request >= 10 && request < 20) {System.out.println("ConcreteHandlerB handled request " + request);} else if (successor != null) {successor.handleRequest(request);}}
}// 客户端
public class Client {public static void main(String[] args) {Handler handlerA = new ConcreteHandlerA();Handler handlerB = new ConcreteHandlerB();handlerA.setSuccessor(handlerB);handlerA.handleRequest(5);  // 应由 ConcreteHandlerA 处理handlerA.handleRequest(15); // 应由 ConcreteHandlerB 处理handlerA.handleRequest(25); // 没有处理者可以处理}
}

C++ 代码案例

#include <iostream>// 抽象处理者
class Handler {
protected:Handler* successor;
public:void setSuccessor(Handler* successor) {this->successor = successor;}virtual void handleRequest(int request) = 0;
};// 具体处理者 A
class ConcreteHandlerA : public Handler {
public:void handleRequest(int request) override {if (request >= 0 && request < 10) {std::cout << "ConcreteHandlerA handled request " << request << std::endl;} else if (successor != nullptr) {successor->handleRequest(request);}}
};// 具体处理者 B
class ConcreteHandlerB : public Handler {
public:void handleRequest(int request) override {if (request >= 10 && request < 20) {std::cout << "ConcreteHandlerB handled request " << request << std::endl;} else if (successor != nullptr) {successor->handleRequest(request);}}
};// 客户端
int main() {Handler* handlerA = new ConcreteHandlerA();Handler* handlerB = new ConcreteHandlerB();handlerA->setSuccessor(handlerB);handlerA->handleRequest(5);  // 应由 ConcreteHandlerA 处理handlerA->handleRequest(15); // 应由 ConcreteHandlerB 处理handlerA->handleRequest(25); // 没有处理者可以处理delete handlerA;delete handlerB;return 0;
}

Python 代码案例

# 抽象处理者
class Handler:def __init__(self):self.successor = Nonedef set_successor(self, successor):self.successor = successordef handle_request(self, request):pass# 具体处理者 A
class ConcreteHandlerA(Handler):def handle_request(self, request):if 0 <= request < 10:print(f"ConcreteHandlerA handled request {request}")elif self.successor is not None:self.successor.handle_request(request)# 具体处理者 B
class ConcreteHandlerB(Handler):def handle_request(self, request):if 10 <= request < 20:print(f"ConcreteHandlerB handled request {request}")elif self.successor is not None:self.successor.handle_request(request)# 客户端
if __name__ == "__main__":handlerA = ConcreteHandlerA()handlerB = ConcreteHandlerB()handlerA.set_successor(handlerB)handlerA.handle_request(5)  # 应由 ConcreteHandlerA 处理handlerA.handle_request(15) # 应由 ConcreteHandlerB 处理handlerA.handle_request(25) # 没有处理者可以处理

Go 代码案例

package mainimport ("fmt"
)// 抽象处理者
type Handler interface {setSuccessor(successor Handler)handleRequest(request int)
}// 具体处理者 A
type ConcreteHandlerA struct {successor Handler
}func (h *ConcreteHandlerA) setSuccessor(successor Handler) {h.successor = successor
}func (h *ConcreteHandlerA) handleRequest(request int) {if request >= 0 && request < 10 {fmt.Printf("ConcreteHandlerA handled request %d\n", request)} else if h.successor != nil {h.successor.handleRequest(request)}
}// 具体处理者 B
type ConcreteHandlerB struct {successor Handler
}func (h *ConcreteHandlerB) setSuccessor(successor Handler) {h.successor = successor
}func (h *ConcreteHandlerB) handleRequest(request int) {if request >= 10 && request < 20 {fmt.Printf("ConcreteHandlerB handled request %d\n", request)} else if h.successor != nil {h.successor.handleRequest(request)}
}// 客户端
func main() {handlerA := &ConcreteHandlerA{}handlerB := &ConcreteHandlerB{}handlerA.setSuccessor(handlerB)handlerA.handleRequest(5)  // 应由 ConcreteHandlerA 处理handlerA.handleRequest(15) // 应由 ConcreteHandlerB 处理handlerA.handleRequest(25) // 没有处理者可以处理
}

4. 总结

责任链模式 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。通过这种方式，可以减少请求发送者和接收者之间的耦合。

主要优点

解耦：请求的发送者和接收者之间没有直接的耦合关系，提高了系统的灵活性。
增强可扩展性：可以动态地增加或改变处理者的数量和顺序，而不会影响客户端。
支持多个处理者：多个处理者可以依次处理同一个请求，增加了系统的灵活性和可配置性。

主要缺点

调试困难：由于请求的处理过程是动态的，调试时可能难以跟踪请求的处理路径。
性能开销：如果链过长，可能会导致性能下降，尤其是在每个处理者都需要执行某些操作时。

适用场景

当一个请求需要被多个对象中的一个或多个处理时。
当处理者的选择需要在运行时动态决定时。
当需要在不明确指定接收者的情况下，向多个对象中的一个发送请求时。
当需要创建一个可灵活配置的处理流程时。