0127_责任链模式(Chain of Responsibility)
责任链模式(Chain of Responsibility)
意图
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
UML 图
优点
- 降低耦合度：请求发送者不需要知道哪个对象处理请求
- 动态组合：可以动态地改变处理链中的对象或顺序
- 增强灵活性：可以灵活地分配职责，添加新的处理者很方便
- 简化对象：每个处理者只需关注自己的职责范围
- 可配置性：处理链可以在运行时进行配置
缺点
- 请求可能未被处理：如果链中没有合适的处理者，请求可能无法被处理
- 性能影响：较长的处理链可能会影响性能
- 调试困难：请求的处理过程可能分散在多个对象中，调试较复杂
- 循环引用风险：如果链配置不当，可能导致循环引用
- 顺序依赖性：处理者的顺序很重要，配置错误可能导致错误的行为
代码示例
以人类和机器人处理不同类型请求为例：
1. 处理者接口 (Handler Interface)
// 请求处理者接口
public interface RequestHandler {
void handleRequest(Request request);
void setNextHandler(RequestHandler nextHandler);
boolean canHandle(Request request);
String getHandlerName();
}
// 请求类
public class Request {
private String type;
private String content;
private int priority; // 优先级
public Request(String type, String content, int priority) {
this.type = type;
this.content = content;
this.priority = priority;
}
public String getType() { return type; }
public String getContent() { return content; }
public int getPriority() { return priority; }
@Override
public String toString() {
return "[" + type + "] " + content + " (优先级: " + priority + ")";
}
}
2. 抽象处理者 (Abstract Handler)
// 抽象处理者
public abstract class AbstractHandler implements RequestHandler {
protected RequestHandler nextHandler;
protected String handlerName;
@Override
public void setNextHandler(RequestHandler nextHandler) {
this.nextHandler = nextHandler;
}
@Override
public void handleRequest(Request request) {
if (canHandle(request)) {
System.out.println(handlerName + " 处理请求: " + request);
processRequest(request);
} else if (nextHandler != null) {
System.out.println(handlerName + " 无法处理，传递给下一个处理者");
nextHandler.handleRequest(request);
} else {
System.out.println("⚠️ 没有处理者能够处理此请求: " + request);
}
}
protected abstract void processRequest(Request request);
public abstract boolean canHandle(Request request);
@Override
public String getHandlerName() {
return handlerName;
}
}
3. 具体处理者 (Concrete Handlers)
// 人类处理者 - 处理情感类请求
public class HumanHandler extends AbstractHandler {
public HumanHandler() {
this.handlerName = "👤 人类处理者";
}
@Override
public boolean canHandle(Request request) {
return request.getType().equals("情感") ||
request.getType().equals("创意") ||
request.getPriority() <= 3; // 处理低优先级请求
}
@Override
protected void processRequest(Request request) {
if (request.getType().equals("情感")) {
System.out.println("💖 人类正在提供情感支持: " + request.getContent());
} else if (request.getType().equals("创意")) {
System.out.println("🎨 人类正在发挥创造力: " + request.getContent());
} else {
System.out.println("👨💼 人类正在处理一般请求: " + request.getContent());
}
}
}
// 机器人处理者 - 处理逻辑类请求
public class RobotHandler extends AbstractHandler {
public RobotHandler() {
this.handlerName = "🤖 机器人处理者";
}
@Override
public boolean canHandle(Request request) {
return request.getType().equals("计算") ||
request.getType().equals("数据") ||
request.getPriority() >= 7; // 处理高优先级请求
}
@Override
protected void processRequest(Request request) {
if (request.getType().equals("计算")) {
System.out.println("🧮 机器人正在执行计算任务: " + request.getContent());
} else if (request.getType().equals("数据")) {
System.out.println("📊 机器人正在处理数据: " + request.getContent());
} else {
System.out.println("⚡ 机器人正在处理紧急请求: " + request.getContent());
}
}
}
// 系统处理者 - 处理系统类请求
public class SystemHandler extends AbstractHandler {
public SystemHandler() {
this.handlerName = "💻 系统处理者";
}
@Override
public boolean canHandle(Request request) {
return request.getType().equals("系统") ||
request.getType().equals("错误");
}
@Override
protected void processRequest(Request request) {
if (request.getType().equals("系统")) {
System.out.println("🔧 系统正在执行维护任务: " + request.getContent());
} else {
System.out.println("❌ 系统正在处理错误: " + request.getContent());
}
}
}
4. 责任链构建器
// 责任链构建器
public class HandlerChainBuilder {
public static RequestHandler buildDefaultChain() {
RequestHandler human = new HumanHandler();
RequestHandler robot = new RobotHandler();
RequestHandler system = new SystemHandler();
// 构建责任链: 人类 -> 机器人 -> 系统
human.setNextHandler(robot);
robot.setNextHandler(system);
return human;
}
public static RequestHandler buildPriorityChain() {
RequestHandler robot = new RobotHandler(); // 高优先级
RequestHandler human = new HumanHandler(); // 低优先级
RequestHandler system = new SystemHandler(); // 系统级
// 构建责任链: 机器人 -> 人类 -> 系统
robot.setNextHandler(human);
human.setNextHandler(system);
return robot;
}
}
5. 客户端代码
public class ChainOfResponsibilityDemo {
public static void main(String[] args) {
System.out.println("=== 责任链模式演示 ===");
// 构建默认责任链
RequestHandler chain = HandlerChainBuilder.buildDefaultChain();
// 创建各种类型的请求
Request[] requests = {
new Request("情感", "需要情感安慰", 2),
new Request("计算", "复杂的数学计算", 8),
new Request("系统", "系统备份任务", 5),
new Request("创意", "设计新方案", 4),
new Request("数据", "大数据分析", 9),
new Request("未知", "未知类型请求", 1)
};
System.out.println("\n📋 处理请求序列:");
for (Request request : requests) {
System.out.println("\n--- 处理新请求 ---");
chain.handleRequest(request);
}
System.out.println("\n=== 优先级责任链 ===");
RequestHandler priorityChain = HandlerChainBuilder.buildPriorityChain();
Request priorityRequest = new Request("一般", "普通请求但高优先级", 9);
System.out.println("处理高优先级请求:");
priorityChain.handleRequest(priorityRequest);
System.out.println("\n=== 动态修改责任链 ===");
// 动态添加新的处理者
RequestHandler customChain = new HumanHandler();
RequestHandler newRobot = new RobotHandler();
RequestHandler newSystem = new SystemHandler();
customChain.setNextHandler(newRobot);
newRobot.setNextHandler(newSystem);
Request customRequest = new Request("计算", "动态链测试", 6);
customChain.handleRequest(customRequest);
}
}
在Java标准库中的应用
责任链模式在Java标准库中的类似应用：
- Servlet过滤器链
// Servlet Filter 责任链
public interface Filter {
void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException;
}
// 过滤器链按顺序调用每个过滤器
- Java日志处理
// java.util.logging 包中的处理器链
Logger logger = Logger.getLogger("example");
logger.addHandler(new ConsoleHandler());
logger.addHandler(new FileHandler("log.txt"));
// 日志消息会依次经过每个处理器
- 异常处理
// 异常处理的责任链模式
try {
// 可能抛出异常的代码
} catch (SpecificException e) {
// 特定异常处理
} catch (GeneralException e) {
// 一般异常处理
} catch (Exception e) {
// 通用异常处理
}
- AOP拦截器链
// Spring AOP 中的拦截器链
public interface MethodInterceptor {
Object invoke(MethodInvocation invocation) throws Throwable;
}
// 多个拦截器形成责任链处理方法的调用
总结
责任链模式通过将多个处理对象连接成一条链，让请求沿着这条链传递，直到有一个对象处理它为止。这种模式有效地解耦了请求发送者和接收者，使得多个对象都有机会处理请求，同时可以动态地组合和修改处理链。
在人类和机器人的例子中，我们可以看到不同类型的请求（情感、计算、系统等）被分配给最适合的处理者。人类擅长处理情感和创意类请求，机器人擅长处理计算和数据类请求，而系统处理者负责系统级别的任务。这种分工协作的方式既提高了处理效率，又保证了每个处理者都能专注于自己擅长的领域。
责任链模式特别适用于：
- 有多个对象可以处理请求，但不确定哪个对象最适合
- 需要动态指定处理请求的对象集合
- 需要在不明确指定接收者的情况下向多个对象发送请求
浙公网安备 33010602011771号