Java案例怎么实现职责链模式？

wen java案例 2026-06-08 45

Java案例：如何实现职责链模式？从理论到实战的深度解析

目录导读

职责链模式的核心概念
为什么需要职责链模式？
职责链模式的Java实现结构
经典案例：请假审批系统
进阶案例：日志过滤器链
与if-else链的对比分析
常见问题FAQ
最佳实践与性能优化建议

职责链模式的核心概念

职责链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求，这种模式将请求的发送者和接收者解耦，让多个对象都有机会处理请求。

Java案例怎么实现职责链模式？

核心三要素：

抽象处理者（Handler）：定义处理请求的接口，并持有对下一个处理者的引用
具体处理者（ConcreteHandler）：实现处理逻辑，决定是否处理或转发请求
客户端（Client）：构建链并向链头发送请求

与现实中类似场景： 就像公司里的请假审批流程——员工请假→组长审批（3天内）→经理审批（7天内）→总监审批（15天内），每个审批者要么自己处理，要么向上传递。

为什么需要职责链模式？

在传统开发中,我们经常遇到这样的问题：

// 糟糕的if-else链
if (request.getType().equals("TYPE_A")) {
    // 处理A类请求
} else if (request.getType().equals("TYPE_B")) {
    // 处理B类请求
} else if (request.getType().equals("TYPE_C")) {
    // 处理C类请求
} else {
    // 默认处理
}

这种写法存在严重缺陷：

耦合度高：所有逻辑集中在一个类中
违反开闭原则：新增处理类型必须修改原有代码
可维护性差：逻辑复杂时易出错

职责链模式通过以下方式解决这些问题：

解耦发送者和接收者：请求者不需要知道谁最终处理
动态组合：链的顺序可以在运行时调整
单一职责：每个处理者只处理自己负责的逻辑

职责链模式的Java实现结构

基本框架代码

// 1. 抽象处理者
public abstract class AbstractHandler {
    protected AbstractHandler nextHandler;
    public void setNextHandler(AbstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    // 模板方法模式确保链式调用
    public final void handleRequest(Request request) {
        if (canHandle(request)) {
            doHandle(request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无人能处理该请求");
        }
    }
    protected abstract boolean canHandle(Request request);
    protected abstract void doHandle(Request request);
}
// 2. 请求对象
public class Request {
    private String type;
    private String content;
    // getter/setter省略
}
// 3. 具体处理者A
public class ConcreteHandlerA extends AbstractHandler {
    @Override
    protected boolean canHandle(Request request) {
        return "TYPE_A".equals(request.getType());
    }
    @Override
    protected void doHandle(Request request) {
        System.out.println("HandlerA处理了请求: " + request.getContent());
    }
}

关键设计点：

使用setNextHandler()形成链表结构
在handleRequest()中采用模板方法模式，确保每个处理者都遵循"判断→处理或传递"的流程
通过canHandle()方法实现灵活的条件判断

经典案例：请假审批系统

需求描述

某公司请假审批规则：

请假天数 ≤ 3天 → 直属主管审批
3天 < 天数 ≤ 7天 → 部门经理审批
7天 < 天数 ≤ 15天 → 总监审批
超过15天 → 需要CEO审批

完整实现代码

// 抽象处理者
abstract class LeaveHandler {
    protected LeaveHandler nextHandler;
    public void setNextHandler(LeaveHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    public void handleLeave(int days, String employee) {
        if (canApprove(days)) {
            approve(days, employee);
        } else if (nextHandler != null) {
            nextHandler.handleLeave(days, employee);
        } else {
            System.out.println("请假天数超过最大限制，需特殊审批");
        }
    }
    protected abstract boolean canApprove(int days);
    protected abstract void approve(int days, String employee);
}
// 具体处理者：主管
class SupervisorHandler extends LeaveHandler {
    @Override
    protected boolean canApprove(int days) {
        return days <= 3;
    }
    @Override
    protected void approve(int days, String employee) {
        System.out.println("主管审批通过：" + employee + "请假" + days + "天");
    }
}
// 具体处理者：经理
class ManagerHandler extends LeaveHandler {
    @Override
    protected boolean canApprove(int days) {
        return days > 3 && days <= 7;
    }
    @Override
    protected void approve(int days, String employee) {
        System.out.println("经理审批通过：" + employee + "请假" + days + "天");
    }
}
// 具体处理者：总监
class DirectorHandler extends LeaveHandler {
    @Override
    protected boolean canApprove(int days) {
        return days > 7 && days <= 15;
    }
    @Override
    protected void approve(int days, String employee) {
        System.out.println("总监审批通过：" + employee + "请假" + days + "天");
    }
}
// 客户端
public class LeaveSystem {
    public static void main(String[] args) {
        // 构建职责链
        LeaveHandler supervisor = new SupervisorHandler();
        LeaveHandler manager = new ManagerHandler();
        LeaveHandler director = new DirectorHandler();
        supervisor.setNextHandler(manager);
        manager.setNextHandler(director);
        // 发起请求
        supervisor.handleLeave(2, "张三");  // 主管审批
        supervisor.handleLeave(5, "李四");  // 经理审批
        supervisor.handleLeave(10, "王五"); // 总监审批
    }
}

运行结果：

主管审批通过：张三请假2天
经理审批通过：李四请假5天
总监审批通过：王五请假10天

案例特点：

处理顺序由链的构建顺序决定（可灵活调整）
新增审批层级只需新增Handler类,无需修改现有代码
请求从链头开始,沿链传递直到被处理

进阶案例：日志过滤器链

需求场景

开发一个可扩展的日志处理系统,支持：

DEBUG级别：仅记录到控制台
INFO级别：记录到控制台+文件
ERROR级别：记录到控制台+文件+邮件通知

实现方案

// 日志等级枚举
enum LogLevel {
    DEBUG, INFO, ERROR
}
// 日志事件
class LogEvent {
    private LogLevel level;
    private String message;
    private long timestamp;
    // 构造函数/getter省略
}
// 抽象日志处理器
abstract class LogHandler {
    protected LogHandler nextHandler;
    private LogLevel level;
    public LogHandler(LogLevel level) {
        this.level = level;
    }
    public void setNextHandler(LogHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    public void handleLog(LogEvent event) {
        if (event.getLevel().ordinal() >= level.ordinal()) {
            write(event);
        }
        if (nextHandler != null) {
            nextHandler.handleLog(event);
        }
    }
    protected abstract void write(LogEvent event);
}
// 控制台日志处理器
class ConsoleHandler extends LogHandler {
    public ConsoleHandler() {
        super(LogLevel.DEBUG);
    }
    @Override
    protected void write(LogEvent event) {
        System.out.println("[CONSOLE] " + event.getMessage());
    }
}
// 文件日志处理器
class FileHandler extends LogHandler {
    public FileHandler() {
        super(LogLevel.INFO);
    }
    @Override
    protected void write(LogEvent event) {
        System.out.println("[FILE] 写入文件: " + event.getMessage());
    }
}
// 邮件日志处理器
class EmailHandler extends LogHandler {
    public EmailHandler() {
        super(LogLevel.ERROR);
    }
    @Override
    protected void write(LogEvent event) {
        System.out.println("[EMAIL] 发送告警邮件: " + event.getMessage());
    }
}
// 客户端
public class LoggerChain {
    public static void main(String[] args) {
        LogHandler console = new ConsoleHandler();
        LogHandler file = new FileHandler();
        LogHandler email = new EmailHandler();
        console.setNextHandler(file);
        file.setNextHandler(email);
        LogEvent debugEvent = new LogEvent(LogLevel.DEBUG, "调试信息");
        LogEvent errorEvent = new LogEvent(LogLevel.ERROR, "系统异常!");
        System.out.println("=== DEBUG级别日志 ===");
        console.handleLog(debugEvent);
        System.out.println("\n=== ERROR级别日志 ===");
        console.handleLog(errorEvent);
    }
}

输出结果：

=== DEBUG级别日志 ===
[CONSOLE] 调试信息
=== ERROR级别日志 ===
[CONSOLE] 系统异常!
[FILE] 写入文件: 系统异常!
[EMAIL] 发送告警邮件: 系统异常!

进阶技巧： 这里使用了不完全传递模式——处理者处理完当前请求后不再阻断，而是继续向下传递，这种模式适用于需要多个处理者共同处理的场景。

与if-else链的对比分析

对比维度	职责链模式	if-else链
代码耦合度	低，处理者独立	高，逻辑集中
扩展性	高，新增类即可	低，需修改原有代码
可测试性	高，可单独测试每个处理者	低，需要整体测试
动态调整	支持运行时调整链顺序	不支持
性能	略有损耗（方法调用链）	直接判断
适用场景	处理者数量不固定或需要动态组合	处理逻辑简单且固定

性能权衡： 在链长度小于10时，职责链模式与方法调用的性能差异可忽略不计，如果链长度超过20且对性能有严格要求，可以考虑使用HashMap替代部分职责链。

常见问题FAQ

Q1：职责链模式和策略模式有什么区别？

A：核心区别在于：策略模式是让客户端选择一种算法，而职责链模式是让多个处理者按顺序尝试处理，形象地说，策略模式是"选择一条路"，职责链模式是"走一条路，不行就换另一条"。

Q2：如何处理职责链中的循环引用？

A：绝对避免循环引用！设计链时确保不会形成闭环，可以在setNextHandler()方法中添加检查逻辑：

public void setNextHandler(AbstractHandler next) {
    if (this == next) throw new IllegalArgumentException("不能自我循环");
    // 或者使用List记录已访问的节点
    this.nextHandler = next;
}

Q3：职责链是否支持异步处理？

A：可以，将每个处理者的handleRequest()方法改为返回CompletableFuture，实现异步链：

public CompletableFuture<Void> handleAsync(Request request) {
    if (canHandle(request)) {
        return CompletableFuture.runAsync(() -> doHandle(request));
    } else if (nextHandler != null) {
        return nextHandler.handleAsync(request);
    }
    return CompletableFuture.completedFuture(null);
}

Q4：职责链模式在Java标准库中有哪些应用？

A：典型应用包括：

javax.servlet.Filter（过滤器链）
java.util.logging.Logger（日志级别链）
Spring Security的过滤链
Netty的ChannelPipeline

最佳实践与性能优化建议

设计原则

处理者应保持无状态：不要在Handler中保存请求相关状态，避免线程安全问题
合理控制链长度：建议不超过10个节点，过长可考虑分层设计
提供默认处理者：链末端添加一个兜底处理者，避免请求无响应

使用泛型增强类型安全：

public abstract class Handler<T> {
 protected Handler<T> next;
 public abstract void handle(T request);
}

性能优化

使用数组替代链表：在确定不频繁调整链结构时，使用数组实现链（如Handler[]）可提升20%-30%性能
对高频请求做缓存：如果同一类型请求频繁出现，可以在处理者中缓存首次判断结果
结合模板方法模式：在抽象处理者中统一处理日志、异常等横切关注点

真实项目中的常见陷阱

忽视链的传递顺序：某电商项目中将审批链写反，导致1天假期也需要CEO审批
处理者内部状态导致线程安全问题：在多线程环境中，避免在处理者中存储可变状态
过度设计：如果只有2-3个处理者且不再增加，直接使用if-else可能更简单

延伸思考： 在实际应用中，职责链模式常与建造者模式结合，实现更优雅的链式调用：

ChainBuilder builder = new ChainBuilder()
    .addHandler(new AuthHandler())
    .addHandler(new ValidationHandler())
    .addHandler(new BusinessHandler());
chain = builder.build();

这种写法既保持了解耦性,又提供了良好的可读性，掌握职责链模式的精髓不在于记住代码模板，而在于理解其"请求传递"的思想，并在合适的场景中灵活运用。

文章来源分析：本文综合了Refactoring Guru、Java Design Patterns和Stack Overflow的权威内容，结合实际项目经验进行重构，确保逻辑清晰且符合SEO优化。

文章字数：约2100字