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 {
@Override
public 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 {
@Override
public 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 = None
def set_successor(self, successor):
self.successor = successor
def 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 main
import (
"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. 总结
责任链模式 是一种行为设计模式，它允许你将请求沿着处理者链进行发送。每个处理者都可以处理请求，或者将其传递给链上的下一个处理者。这种模式使得多个对象都有机会处理请求，而无需提前指定具体的处理者。通过这种方式，可以减少请求发送者和接收者之间的耦合。
主要优点
- 解耦：请求的发送者和接收者之间没有直接的耦合关系，提高了系统的灵活性。
- 增强可扩展性：可以动态地增加或改变处理者的数量和顺序，而不会影响客户端。
- 支持多个处理者：多个处理者可以依次处理同一个请求，增加了系统的灵活性和可配置性。
主要缺点
- 调试困难：由于请求的处理过程是动态的，调试时可能难以跟踪请求的处理路径。
- 性能开销：如果链过长，可能会导致性能下降，尤其是在每个处理者都需要执行某些操作时。
适用场景
- 当一个请求需要被多个对象中的一个或多个处理时。
- 当处理者的选择需要在运行时动态决定时。
- 当需要在不明确指定接收者的情况下，向多个对象中的一个发送请求时。
- 当需要创建一个可灵活配置的处理流程时。
