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

琢磨先生David2025-05-31 3:05

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

（一）模式定义与本质

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

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

（二）核心应用场景

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

（三）模式优缺点分析

优点：

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

缺点：

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

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

（一）四大核心角色

  1. 抽象处理者（Handler）：定义处理请求的接口，包含一个指向后继处理者的引用，并实现默认的请求传递方法（如设置下一个处理者、传递请求等）。
  2. 具体处理者（Concrete Handler）：实现抽象处理者定义的处理方法，判断是否能够处理当前请求，若能则处理，否则将请求传递给后继处理者。
  3. 请求对象（Request）：封装请求的相关信息，供处理者判断是否需要处理。
  4. 客户端（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

（三）关键交互流程

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

三、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 setters
    public 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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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 {
    @Override
    public 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天，原因：产假

（三）实现关键点解析

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

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

（一）带返回值的责任链

在上述案例中，处理者处理请求后通常不会返回结果，但在实际场景中，可能需要处理者返回处理结果（如审批是否通过、处理后的数据等）。此时可以修改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 {
    @Override
    public 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）或数据库来存储处理者的顺序，运行时动态加载并构建责任链。

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

  1. 创建配置文件approvers.config：

properties

复制代码 
approver1=com.example.TeamLeaderApprover
approver2=com.example.DepartmentManagerApprover
approver3=com.example.DirectorApprover
approver4=com.example.GeneralManagerApprover
  1. 客户端动态加载处理者并构建链：

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 或自定义注解来简化责任链的构建。

步骤如下：

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

java

复制代码 
@Component
public class TeamLeaderApprover extends Approver {
    // ... 处理逻辑
}
  1. 使用@Autowired注入所有处理者，并按照顺序构建链：

java

复制代码 
@Service
public class ApproveService {
    private List<Approver> approvers;

    @Autowired
    public 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）

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

六、最佳实践与注意事项

（一）链的长度控制

避免责任链过长，过长的链会导致请求处理效率低下，且调试困难。可以通过日志记录链的处理过程，或者在链中设置最大处理深度限制。

（二）链尾处理

必须确保责任链有一个最终处理者（如默认处理者），避免请求未被处理的情况。例如在请假审批系统中，总经理作为链尾处理者，处理所有超过 7 天的请假请求。

（三）处理者的单一职责

每个处理者应专注于处理特定类型的请求，遵循单一职责原则，避免处理者承担过多职责，导致逻辑复杂。

（四）日志与调试

在处理者中加入日志记录，记录请求的处理过程，方便调试和问题排查。例如记录请求进入处理者的时间、处理结果、传递给下一个处理者的时间等。

（五）性能优化

如果责任链中的处理者较多，且大部分请求需要传递到链尾才能处理，可以考虑使用缓存或预处理机制，提前判断请求应该由哪个处理者处理，避免逐个传递请求。

七、总结与拓展

责任链模式通过将处理者连成链条，实现了请求处理的解耦和灵活扩展，是处理多级流程、过滤链等场景的理想选择。在 Java 开发中，我们可以通过抽象类和接口定义处理者，通过组合模式构建责任链，结合 Spring 等框架实现更高效的管理。

随着微服务架构的普及，责任链模式的思想也被应用到分布式系统中，如请求拦截链、网关过滤器链等。深入理解责任链模式的核心原理，能够帮助我们更好地设计可扩展的系统架构，应对复杂的业务需求变化。

在实际项目中，是否选择责任链模式需要根据具体场景权衡，考虑请求处理的复杂度、处理者的动态性以及系统的可维护性等因素。通过合理应用责任链模式，我们可以构建出更加灵活、健壮的软件系统。

相关推荐
天天摸鱼的java工程师37 分钟前
MySQL 千万数据下 Redis 热点数据管理策略
java·后端·面试
天天摸鱼的java工程师39 分钟前
为什么 MySQL 不推荐使用雪花 ID 和 UUID 做主键？
java·后端·面试
Kim Jackson43 分钟前
我的世界Java版1.21.4的Fabric模组开发教程(十一)创建方块
java·游戏·fabric
weixin_419658311 小时前
Java 认识异常
java·开发语言
陌殇殇1 小时前
005 ElasticSearch 许可证过期问题
java·elasticsearch·搜索引擎
风象南1 小时前
SpringBoot数据转换的4种对象映射方案
java·spring boot·后端
庄小焱1 小时前
设计模式——单例设计模式（创建型）
设计模式
勤奋的知更鸟1 小时前
Java 单例模式详解
java·开发语言·单例模式
Jim-zf1 小时前
Flutter 嵌套H5 传参数
java·开发语言·flutter
Code哈哈笑2 小时前
【基于SpringBoot的图书购买系统】Redis中的数据以分页的形式展示：从配置到前后端交互的完整实现
java·spring boot·redis·后端·spring·交互
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【无人机】无人机通信模块，无人机图数传模块的介绍，数传，图传，图传数传一体电台，05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06DeepSeek各版本说明与优缺点分析07Trae AI 开发工具使用手册08Coze扣子平台完整体验和实践（附国内和国际版对比）09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总