本文将深入探讨职责链模式的工作原理、实现方式,并分析其在现代软件架构中的应用。
引言
在复杂的业务逻辑中,请求的传递和处理往往涉及多个处理对象。传统的处理方式可能会导致组件之间高度耦合,难以维护和扩展。
职责链模式通过将请求沿链传递,直到找到合适的处理者,有效解决了这一问题。
概述
职责链模式是一种行为设计模式,它允许多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。
这种模式将对象组成一条链,并沿着这条链传递请求,直到有对象处理它为止。
核心概念
请求(Request):需要处理的任务或信息。
处理者(Handler):链中的节点,负责处理请求或转发请求。
工作原理
- 客户端创建请求并将其发送到链的头部;
- 链中的每个处理者决定是否能够处理该请求;
- 如果能够处理,执行相应操作;否则,将请求转发到链中的下一个处理者;
- 这个过程一直持续,直到请求被处理或到达链的末端。
代码实现
方式一
Handler
是所有处理器类的抽象父类,handle()
方法是抽象方法。
每个具体的处理器类HandlerA
,HandlerB
的handle()
代码结构类似,如果它能处理该请求,就不继续向下传递;如果不能处理,则交由后面的处理器来处理(即调用successor.handle()
)。
HandlerChain
是处理器链,一个记录了链头、链尾的链表。
public abstract class Handler {
protected Handler successor = null;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public final void handle() {
boolean handled = doHandle();
if (successor != null && !handled) {
successor.handle();
}
}
protected abstract boolean doHandle();
}
public class HandlerA extends Handler {
@Override
protected boolean doHandle() {
boolean handled = false;
//...
return handled;
}
}
public class HandlerB extends Handler {
@Override
protected boolean doHandle() {
boolean handled = false;
//...
return handled;
}
}
public class HandlerChain {
private Handler head = null;
private Handler tail = null;
public void addHandler(Handler handler) {
handler.setSuccessor(null);
if (head == null) {
head = handler;
tail = handler;
return;
}
tail.setSuccessor(handler);
tail = handler;
}
public void handle() {
if (head != null) {
head.handle();
}
}
}
// 使用举例
public class Application {
public static void main(String[] args) {
HandlerChain chain = new HandlerChain();
chain.addHandler(new HandlerA());
chain.addHandler(new HandlerB());
chain.handle();
}
}
方式 2
HandlerChain
类用数组来保存所有的处理器类,且在handler()
函数中调用每个处理器类的handler()
函数。
public interface IHandler {
boolean handle();
}
public class HandlerA implements IHandler {
@Override
public boolean handle() {
boolean handled = false;
//...
return handled;
}
}
public class HandlerB implements IHandler {
@Override
public boolean handle() {
boolean handled = false;
//...
return handled;
}
}
public class HandlerChain {
private List<IHandler> handlers = new ArrayList<>();
public void addHandler(IHandler handler) {
this.handlers.add(handler);
}
public void handle() {
for (IHandler handler : handlers) {
boolean handled = handler.handle();
if (handled) {
break;
}
}
}
}
// 使用举例
public class Application {
public static void main(String[] args) {
HandlerChain chain = new HandlerChain();
chain.addHandler(new HandlerA());
chain.addHandler(new HandlerB());
chain.handle();
}
}
变体
实际上,职责链模式还有一种变体,那就是请求会被所有的处理器都处理一遍,不存在中途停止的情况。
链表实现
public abstract class Handler {
protected Handler successor = null;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public final void handle() {
doHandle();
if (successor != null) {
successor.handle();
}
}
protected abstract void doHandle();
}
public class HandlerA extends Handler {
@Override
protected void doHandle() {
//...
}
}
public class HandlerB extends Handler {
@Override
protected void doHandle() {
//...
}
}
public class HandlerChain {
private Handler head = null;
private Handler tail = null;
public void addHandler(Handler handler) {
handler.setSuccessor(null);
if (head == null) {
head = handler;
tail = handler;
return;
}
tail.setSuccessor(handler);
tail = handler;
}
public void handle() {
if (head != null) {
head.handle();
}
}
}
// 使用举例
public class Application {
public static void main(String[] args) {
HandlerChain chain = new HandlerChain();
chain.addHandler(new HandlerA());
chain.addHandler(new HandlerB());
chain.handle();
}
}
数组实现
public interface IHandler {
void handle();
}
public class HandlerA implements IHandler {
@Override
public void handle() {
//...
}
}
public class HandlerB implements IHandler {
@Override
public boolean handle() {
//...
}
}
public class HandlerChain {
private List<IHandler> handlers = new ArrayList<>();
public void addHandler(IHandler handler) {
this.handlers.add(handler);
}
public void handle() {
for (IHandler handler : handlers) {
handler.handle();
}
}
}
// 使用举例
public class Application {
public static void main(String[] args) {
HandlerChain chain = new HandlerChain();
chain.addHandler(new HandlerA());
chain.addHandler(new HandlerB());
chain.handle();
}
}
性能和设计考量
职责链模式提供了请求处理的灵活性和可扩展性,但也需要考虑以下方面:
- 性能问题:如果链过长,请求的传递可能会引入延迟。
- 未知终点:请求可能在链的末端仍未被处理,需要有默认的处理策略。
最佳实践
- 确保每个处理者明确自己的职责范围;
- 避免创建过长的职责链,以免影响性能;
- 提供默认的处理者,以防请求未被处理。
总结
职责链模式是一种强大且灵活的设计模式,它通过解耦请求发送者和接收者,提高了系统的可扩展性和可维护性。理解其工作原理和实现方式,有助于我们在面对复杂的请求处理逻辑时,设计出更加优雅和高效的解决方案。
另外,职责链模式经常用来开发框架的过滤器
和拦截器
,如Servlet Filter
和Spring Interceptor
,关于底层代码分析,将在后面文章中单独讲解。