职责链模式(Chain of Responsibility Pattern)是一种行为型设计模式,用于将请求的发送者和接收者解耦,并使多个对象都有机会处理这个请求。在职责链模式中,请求沿着一个链传递,直到有一个对象处理它为止。
在职责链模式中,通常有以下几个角色:
- 抽象处理者(Handler):定义处理请求的接口,并维护一个指向下一个处理者的引用。通常包含一个处理方法,用于处理请求或将请求传递给下一个处理者。
- 具体处理者(ConcreteHandler):实现抽象处理者接口,具体处理请求的逻辑。如果自己无法处理请求,可以将请求传递给下一个处理者。
- 客户端(Client):创建职责链,并将请求发送给链中的第一个处理者。
下面是一个简单的示例,说明职责链模式的工作原理:
// 抽象处理者
public abstract class Handler {
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public void handleRequest(Request request) {
if (canHandle(request)) {
processRequest(request);
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
// 没有处理者能够处理该请求
System.out.println("No handler found for the request.");
}
}
protected abstract boolean canHandle(Request request);
protected abstract void processRequest(Request request);
}
// 具体处理者A
public class ConcreteHandlerA extends Handler {
@Override
protected boolean canHandle(Request request) {
// 判断是否能够处理该请求
return request.getType().equals("A");
}
@Override
protected void processRequest(Request request) {
// 处理请求的逻辑
System.out.println("ConcreteHandlerA is handling the request.");
}
}
// 具体处理者B
public class ConcreteHandlerB extends Handler {
@Override
protected boolean canHandle(Request request) {
// 判断是否能够处理该请求
return request.getType().equals("B");
}
@Override
protected void processRequest(Request request) {
// 处理请求的逻辑
System.out.println("ConcreteHandlerB is handling the request.");
}
}
// 请求类
public class Request {
private String type;
public Request(String type) {
this.type = type;
}
public String getType() {
return type;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建处理者
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
// 设置处理者的下一个处理者
handlerA.setNextHandler(handlerB);
// 创建请求
Request requestA = new Request("A");
Request requestB = new Request("B");
Request requestC = new Request("C");
// 发送请求
handlerA.handleRequest(requestA); // 输出:ConcreteHandlerA is handling the request.
handlerA.handleRequest(requestB); // 输出:ConcreteHandlerB is handling the request.
handlerA.handleRequest(requestC); // 输出:No handler found for the request.
}
}
在上面的示例中,抽象处理者(Handler)定义了处理请求的接口,并维护了一个指向下一个处理者的引用。具体处理者(ConcreteHandlerA和ConcreteHandlerB)实现了抽象处理者接口,并根据自身的能力判断是否能够处理请求。如果自己无法处理请求,就将请求传递给下一个处理者。客户端(Client)创建职责链,并将请求发送给链中的第一个处理者。
在示例中,请求类型为"A"的请求会被ConcreteHandlerA处理,请求类型为"B"的请求会被ConcreteHandlerB处理,而请求类型为"C"的请求没有任何处理者能够处理,最终输出"No handler found for the request."。
职责链模式的优点是将请求的发送者和接收者解耦,增加了系统的灵活性。同时,职责链模式也有可能导致请求的处理链过长,影响性能,因此在使用时需要注意控制链的长度。