责任链模式：构建灵活可扩展的请求处理体系（Java 实现详解）-海口c网

一、责任链模式核心概念解析

（一）模式定义与本质

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，其核心思想是将多个处理者对象连成一条链，并沿着这条链传递请求，直到有某个处理者对象处理它为止。这种模式通过将请求的发送者和接收者解耦，使得多个对象都有机会处理请求，从而避免请求发送者与具体处理者之间的紧耦合。

责任链模式的本质可以概括为：传递请求，推卸责任。每个处理者只负责处理自己职责范围内的请求，对于超出职责范围的请求，则将其传递给链中的下一个处理者，形成一个灵活请求处理链条。

（二）核心应用场景

多级审批流程：如请假审批、费用报销审批等，不同级别的审批者处理不同额度或类型的请求。
过滤链场景：例如日志处理中的多级过滤、HTTP 请求的过滤器链。
错误处理链：在复杂系统中，不同类型的错误由不同的处理器进行处理。
事件处理机制：图形界面开发中，事件可能需要多个组件依次处理，如按钮点击事件可能先由按钮处理，再传递给容器组件。

（三）模式优缺点分析

优点：

解耦请求发送者与处理者：发送者无需知道具体哪个处理者处理请求，只需将请求发送到链上。
动态灵活：可以在运行时动态调整责任链的顺序，新增或删除处理者，而无需修改客户端代码。
符合开闭原则：新增处理者只需实现接口并加入链中，不影响现有代码。

缺点：

请求可能未被处理：如果责任链中没有处理者能够处理该请求，可能导致请求丢失，需要在链尾设置默认处理者。
调试难度增加：请求的处理路径可能较长，调试时需要跟踪整个链的处理过程。
性能开销：每个请求都需要沿着链进行传递，可能会带来一定的性能损失，尤其是在链较长时。

二、责任链模式的核心角色与 UML 结构

（一）四大核心角色

抽象处理者（Handler）：定义处理请求的接口，包含一个指向后继处理者的引用，并实现默认的请求传递方法（如设置下一个处理者、传递请求等）。
具体处理者（Concrete Handler）：实现抽象处理者定义的处理方法，判断是否能够处理当前请求，若能则处理，否则将请求传递给后继处理者。
请求对象（Request）：封装请求的相关信息，供处理者判断是否需要处理。
客户端（Client）：创建责任链，并向链的头部发送请求。

（二）UML 类图结构

plantuml

@startuml
class Client{- Handler headHandler+ void sendRequest(Request request)
}
class Handler{- Handler nextHandler+ setNextHandler(Handler handler)+ handleRequest(Request request)
}
class ConcreteHandler1{+ handleRequest(Request request)
}
class ConcreteHandler2{+ handleRequest(Request request)
}
class Request{- Object data// getters and setters
}
Client --> Handler
Handler <|-- ConcreteHandler1
Handler <|-- ConcreteHandler2
Handler "1" -- "0..1" Handler : nextHandler
@enduml

（三）关键交互流程

客户端创建具体处理者实例，并通过setNextHandler方法将处理者连接成链，确定链的顺序。
客户端向链的头部处理者（通常是第一个处理者）发送请求。
头部处理者接收到请求后，先判断自己是否能够处理该请求：
- 若能处理，则执行具体的处理逻辑，处理完毕后根据需要决定是否继续传递请求（通常处理后不再传递）。
- 若不能处理，则调用nextHandler的handleRequest方法，将请求传递给下一个处理者。
后续处理者重复上述步骤，直到请求被处理或到达链尾。

三、Java 手写责任链模式实现 —— 请假审批系统

（一）业务场景说明

假设我们需要实现一个员工请假审批系统，请假流程如下：

请假天数≤1 天，由直属领导审批。
1 天 < 请假天数≤3 天，由部门经理审批。
3 天 < 请假天数≤7 天，由总监审批。
请假天数 > 7 天，由总经理审批。

（二）实现步骤详解

1. 定义请求类（Request）

java

public class LeaveRequest {private String employeeName; // 员工姓名private int days; // 请假天数private String reason; // 请假原因public LeaveRequest(String employeeName, int days, String reason) {this.employeeName = employeeName;this.days = days;this.reason = reason;}// getters and setterspublic String getEmployeeName() { return employeeName; }public int getDays() { return days; }public String getReason() { return reason; }
}

2. 定义抽象处理者（Handler）

java

public abstract class Approver {protected Approver nextApprover; // 后继处理者// 设置下一个处理者public void setNextApprover(Approver nextApprover) {this.nextApprover = nextApprover;}// 处理请求的抽象方法public abstract void processRequest(LeaveRequest request);
}

3. 实现具体处理者（Concrete Handler）

直属领导（TeamLeaderApprover）：

java

public class TeamLeaderApprover extends Approver {@Overridepublic void processRequest(LeaveRequest request) {if (request.getDays() <= 1) {System.out.println("直属领导" + this + "审批通过：" + request.getEmployeeName() + "请假" + request.getDays() + "天，原因：" + request.getReason());} else {if (nextApprover != null) {nextApprover.processRequest(request); // 传递给下一个处理者} else {System.out.println("请假天数过长，无人审批！");}}}
}

部门经理（DepartmentManagerApprover）：

java

public class DepartmentManagerApprover extends Approver {@Overridepublic void processRequest(LeaveRequest request) {if (request.getDays() > 1 && request.getDays() <= 3) {System.out.println("部门经理" + this + "审批通过：" + request.getEmployeeName() + "请假" + request.getDays() + "天，原因：" + request.getReason());} else {if (nextApprover != null) {nextApprover.processRequest(request);} else {System.out.println("请假天数过长，无人审批！");}}}
}

总监（DirectorApprover）：

java

public class DirectorApprover extends Approver {@Overridepublic void processRequest(LeaveRequest request) {if (request.getDays() > 3 && request.getDays() <= 7) {System.out.println("总监" + this + "审批通过：" + request.getEmployeeName() + "请假" + request.getDays() + "天，原因：" + request.getReason());} else {if (nextApprover != null) {nextApprover.processRequest(request);} else {System.out.println("请假天数过长，无人审批！");}}}
}

总经理（GeneralManagerApprover）：

java

public class GeneralManagerApprover extends Approver {@Overridepublic void processRequest(LeaveRequest request) {if (request.getDays() > 7) {System.out.println("总经理" + this + "审批通过：" + request.getEmployeeName() + "请假" + request.getDays() + "天，原因：" + request.getReason());} else {if (nextApprover != null) {nextApprover.processRequest(request);} else {System.out.println("请假天数过长，无人审批！");}}}
}

4. 客户端调用（Client）

java

public class Client {public static void main(String[] args) {// 创建处理者实例Approver teamLeader = new TeamLeaderApprover();Approver departmentManager = new DepartmentManagerApprover();Approver director = new DirectorApprover();Approver generalManager = new GeneralManagerApprover();// 构建责任链teamLeader.setNextApprover(departmentManager);departmentManager.setNextApprover(director);director.setNextApprover(generalManager);// 创建请求LeaveRequest request1 = new LeaveRequest("张三", 1, "病假");LeaveRequest request2 = new LeaveRequest("李四", 2, "事假");LeaveRequest request3 = new LeaveRequest("王五", 5, "婚假");LeaveRequest request4 = new LeaveRequest("赵六", 10, "产假");// 发送请求teamLeader.processRequest(request1);teamLeader.processRequest(request2);teamLeader.processRequest(request3);teamLeader.processRequest(request4);}
}

5. 运行结果

plaintext

直属领导TeamLeaderApprover@1540e19d审批通过：张三请假1天，原因：病假
部门经理DepartmentManagerApprover@677327b6审批通过：李四请假2天，原因：事假
总监DirectorApprover@14ae5a5审批通过：王五请假5天，原因：婚假
总经理GeneralManagerApprover@7f31245a审批通过：赵六请假10天，原因：产假

（三）实现关键点解析

处理者链的构建：通过setNextApprover方法将处理者依次连接，形成责任链。链的顺序非常重要，决定了请求的处理顺序，通常按照处理者的处理能力从小到大或从低到高排列。
请求处理逻辑：每个具体处理者首先判断自己是否能处理当前请求，处理逻辑可以是基于请求的属性（如请假天数）、权限等。若不能处理，则传递给下一个处理者，注意要处理nextApprover为null的情况（链尾），避免空指针异常。
抽象处理者的设计：抽象类中定义了后继处理者的引用和设置方法，以及处理请求的抽象方法，确保所有具体处理者具有一致的接口。

四、责任链模式的优化与扩展

（一）带返回值的责任链

在上述案例中，处理者处理请求后通常不会返回结果，但在实际场景中，可能需要处理者返回处理结果（如审批是否通过、处理后的数据等）。此时可以修改processRequest方法，使其返回一个结果对象。

修改抽象处理者：

java

public abstract class Approver {// ... 其他代码不变public abstract ApproveResult processRequest(LeaveRequest request);
}// 审批结果类
public class ApproveResult {private boolean approved;private String message;// 构造方法、getters and setters
}

具体处理者返回结果：

java

public class TeamLeaderApprover extends Approver {@Overridepublic ApproveResult processRequest(LeaveRequest request) {ApproveResult result = new ApproveResult();if (request.getDays() <= 1) {result.setApproved(true);result.setMessage("直属领导审批通过");} else {if (nextApprover != null) {result = nextApprover.processRequest(request); // 传递请求并获取结果} else {result.setApproved(false);result.setMessage("无人审批");}}return result;}
}

（二）动态构建责任链

在客户端硬编码责任链的顺序不够灵活，特别是当链的结构可能频繁变化时。可以通过配置文件（如 XML、JSON）或数据库来存储处理者的顺序，运行时动态加载并构建责任链。

示例：从配置文件加载责任链

创建配置文件approvers.config：

properties

approver1=com.example.TeamLeaderApprover
approver2=com.example.DepartmentManagerApprover
approver3=com.example.DirectorApprover
approver4=com.example.GeneralManagerApprover

客户端动态加载处理者并构建链：

java

public class Client {public static void main(String[] args) throws Exception {Properties properties = new Properties();properties.load(new FileInputStream("approvers.config"));List<Approver> approvers = new ArrayList<>();for (int i = 1; i <= properties.size(); i++) {String className = properties.getProperty("approver" + i);Class<?> clazz = Class.forName(className);Approver approver = (Approver) clazz.newInstance();approvers.add(approver);}// 构建责任链for (int i = 0; i < approvers.size() - 1; i++) {approvers.get(i).setNextApprover(approvers.get(i + 1));}// 发送请求...}
}

（三）使用 Spring 实现责任链（依赖注入方式）

在 Spring 框架中，可以利用依赖注入来管理处理者实例，并通过 AOP 或自定义注解来简化责任链的构建。

步骤如下：

定义处理者接口和抽象类（同前文）。
将具体处理者声明为 Spring Bean：

java

@Component
public class TeamLeaderApprover extends Approver {// ... 处理逻辑
}

使用@Autowired注入所有处理者，并按照顺序构建链：

java

@Service
public class ApproveService {private List<Approver> approvers;@Autowiredpublic ApproveService(List<Approver> approvers) {// 假设approvers已按顺序注入，可能需要通过@Order注解排序for (int i = 0; i < approvers.size() - 1; i++) {approvers.get(i).setNextApprover(approvers.get(i + 1));}}public void approve(LeaveRequest request) {approvers.get(0).processRequest(request); // 从链头开始处理}
}

五、责任链模式与其他设计模式的对比

（一）vs 策略模式（Strategy Pattern）

对比维度	责任链模式	策略模式
目的	处理请求链，一个请求可能被多个处理者处理	封装不同算法策略，选择其中一种算法处理请求
结构	处理者之间形成链式结构，请求沿链传递	策略类之间是平行的，客户端直接选择具体策略
交互方式	处理者自动传递请求，无需客户端干预	客户端主动选择具体策略并调用
适用场景	请求需要按顺序经过多个处理者处理	需要动态切换不同算法实现

（二）vs 状态模式（State Pattern）

对比维度	责任链模式	状态模式
核心思想	传递请求，多个处理者可能处理同一个请求	根据对象状态变化改变行为，状态之间自动切换
处理者关系	处理者之间是链式的，无状态关联	状态对象之间通常是互斥的，对象当前状态决定行为
请求处理	请求可能被多个处理者处理（取决于链的顺序）	请求由当前状态对象处理，一个请求对应一个状态处理

（三）vs 观察者模式（Observer Pattern）

对比维度	责任链模式	观察者模式
通信方向	请求由发送者向处理者单向传递	主题与观察者之间是双向通信（主题通知观察者）
处理方式	处理者按顺序处理请求，通常只有一个处理者处理	多个观察者可以同时响应主题的变化
解耦程度	发送者与处理者解耦，但处理者之间有链式关联	主题与观察者解耦，观察者之间无关联