小谈设计模式（25）—职责链模式
小谈设计模式（25）—职责链模式
专栏介绍
主要对目前市面上常见的23种设计模式进行逐一分析和总结，希望有兴趣的小伙伴们可以看一下，会持续更新的。希望各位可以监督我，我们一起学习进步，加油，各位。
职责链模式
职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。职责链模式将请求的发送者和接收者解耦，让多个对象都有机会处理请求，直到其中一个对象处理成功为止。
分析
在职责链模式中，通常会有一个抽象处理者（Handler）类，它定义了处理请求的接口和一个指向下一个处理者的引用。具体处理者（ConcreteHandler）类实现了抽象处理者的接口，负责处理特定的请求，如果自己无法处理，则将请求传递给下一个处理者。
角色分析
抽象处理者（Handler）
定义了处理请求的接口，并持有下一个处理者的引用。
具体处理者（ConcreteHandler）
实现了抽象处理者的接口，负责处理特定的请求，如果无法处理则将请求传递给下一个处理者。
客户端（Client）
创建处理链，并将请求发送给链中的第一个处理者。
优缺点分析
优点
1
降低了请求的发送者和接收者之间的耦合，请求发送者无需知道具体的处理者，只需将请求发送给第一个处理者即可。
2
可以动态地增加或修改处理链，增强了灵活性。
3
可以将请求的处理逻辑分布到多个处理者中，避免了单个处理者处理过多的责任。
缺点
1
请求可能无法被处理，或者没有处理者能够处理请求，需要在链的末尾设置一个默认的处理者来处理这种情况。
2
请求可能会被多个处理者都处理，需要控制好处理者之间的关系，避免重复处理。
应用场景
多级审批流程
例如请假审批、报销审批等，每个级别的领导都有机会处理请求。
异常处理
例如在一个系统中，可以通过职责链模式将不同类型的异常交给不同的处理者处理。
日志记录
例如在一个系统中，可以通过职责链模式将不同级别的日志交给不同的处理者记录。
Java程序分析
首先，我们需要定义抽象处理者（Handler）接口，包含处理请求的方法和设置下一个处理者的方法：
public abstract class Handler {
protected Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public abstract void handleRequest(Request request);
}然后，我们创建具体处理者（ConcreteHandler）类，实现抽象处理者接口，并在处理请求时判断是否能够处理该请求，如果能够处理则进行处理，否则将请求传递给下一个处理者：
public class ConcreteHandlerA extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals("TypeA")) {
System.out.println("ConcreteHandlerA handles the request.");
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
public class ConcreteHandlerB extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals("TypeB")) {
System.out.println("ConcreteHandlerB handles the request.");
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
public class ConcreteHandlerC extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals("TypeC")) {
System.out.println("ConcreteHandlerC handles the request.");
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}最后，我们创建客户端（Client）类，创建处理链并将请求发送给链中的第一个处理者：
public class Client {
public static void main(String[] args) {
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
Handler handlerC = new ConcreteHandlerC();
handlerA.setNextHandler(handlerB);
handlerB.setNextHandler(handlerC);
Request requestA = new Request("TypeA");
Request requestB = new Request("TypeB");
Request requestC = new Request("TypeC");
Request requestD = new Request("TypeD");
handlerA.handleRequest(requestA);
handlerA.handleRequest(requestB);
handlerA.handleRequest(requestC);
handlerA.handleRequest(requestD);
}
}输出结果
ConcreteHandlerA handles the request.
ConcreteHandlerB handles the request.
ConcreteHandlerC handles the request.
No handler can handle the request.
分析
在这个示例中，我们创建了三个具体处理者（ConcreteHandlerA、ConcreteHandlerB、ConcreteHandlerC），它们分别能够处理不同类型的请求。我们通过设置每个处理者的下一个处理者，形成了一个处理链。当客户端发送请求时，请求会从链的第一个处理者开始处理，如果某个处理者能够处理该请求，则进行处理，否则将请求传递给下一个处理者，直到找到能够处理请求的处理者为止。如果整个链都无法处理请求，则输出提示信息。