0127_责任链模式(Chain of Responsibility)

责任链模式(Chain of Responsibility)

意图

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

UML 图

优点

1. 降低耦合度：请求发送者不需要知道哪个对象处理请求
2. 动态组合：可以动态地改变处理链中的对象或顺序
3. 增强灵活性：可以灵活地分配职责，添加新的处理者很方便
4. 简化对象：每个处理者只需关注自己的职责范围
5. 可配置性：处理链可以在运行时进行配置

缺点

1. 请求可能未被处理：如果链中没有合适的处理者，请求可能无法被处理
2. 性能影响：较长的处理链可能会影响性能
3. 调试困难：请求的处理过程可能分散在多个对象中，调试较复杂
4. 循环引用风险：如果链配置不当，可能导致循环引用
5. 顺序依赖性：处理者的顺序很重要，配置错误可能导致错误的行为

代码示例

以人类和机器人处理不同类型请求为例：

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; }@Overridepublic String toString() {return "[" + type + "] " + content + " (优先级: " + priority + ")";}
}

2. 抽象处理者 (Abstract Handler)

// 抽象处理者
public abstract class AbstractHandler implements RequestHandler {protected RequestHandler nextHandler;protected String handlerName;@Overridepublic void setNextHandler(RequestHandler nextHandler) {this.nextHandler = nextHandler;}@Overridepublic 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);@Overridepublic String getHandlerName() {return handlerName;}
}

3. 具体处理者 (Concrete Handlers)

// 人类处理者 - 处理情感类请求
public class HumanHandler extends AbstractHandler {public HumanHandler() {this.handlerName = "👤 人类处理者";}@Overridepublic boolean canHandle(Request request) {return request.getType().equals("情感") || request.getType().equals("创意") ||request.getPriority() <= 3; // 处理低优先级请求}@Overrideprotected 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 = "🤖 机器人处理者";}@Overridepublic boolean canHandle(Request request) {return request.getType().equals("计算") || request.getType().equals("数据") ||request.getPriority() >= 7; // 处理高优先级请求}@Overrideprotected 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 = "💻 系统处理者";}@Overridepublic boolean canHandle(Request request) {return request.getType().equals("系统") || request.getType().equals("错误");}@Overrideprotected 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标准库中的类似应用：

1. Servlet过滤器链

// Servlet Filter 责任链
public interface Filter {void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;
}// 过滤器链按顺序调用每个过滤器

2. Java日志处理

// java.util.logging 包中的处理器链
Logger logger = Logger.getLogger("example");
logger.addHandler(new ConsoleHandler());
logger.addHandler(new FileHandler("log.txt"));
// 日志消息会依次经过每个处理器

3. 异常处理

// 异常处理的责任链模式
try {// 可能抛出异常的代码
} catch (SpecificException e) {// 特定异常处理
} catch (GeneralException e) {// 一般异常处理
} catch (Exception e) {// 通用异常处理
}

4. AOP拦截器链

// Spring AOP 中的拦截器链
public interface MethodInterceptor {Object invoke(MethodInvocation invocation) throws Throwable;
}
// 多个拦截器形成责任链处理方法的调用

总结

责任链模式通过将多个处理对象连接成一条链，让请求沿着这条链传递，直到有一个对象处理它为止。这种模式有效地解耦了请求发送者和接收者，使得多个对象都有机会处理请求，同时可以动态地组合和修改处理链。

在人类和机器人的例子中，我们可以看到不同类型的请求（情感、计算、系统等）被分配给最适合的处理者。人类擅长处理情感和创意类请求，机器人擅长处理计算和数据类请求，而系统处理者负责系统级别的任务。这种分工协作的方式既提高了处理效率，又保证了每个处理者都能专注于自己擅长的领域。

责任链模式特别适用于：

• 有多个对象可以处理请求，但不确定哪个对象最适合
• 需要动态指定处理请求的对象集合
• 需要在不明确指定接收者的情况下向多个对象发送请求