设计模式精讲 Day 13：责任链模式（Chain of Responsibility Pattern）

发布于：2025-06-28 ⋅ 阅读:(17) ⋅ 点赞:(0)

【设计模式精讲 Day 13】责任链模式（Chain of Responsibility Pattern）

文章内容

在“设计模式精讲”系列的第13天，我们将深入讲解责任链模式（Chain of Responsibility Pattern）。这是一种行为型设计模式，它通过将请求的发送者和接收者解耦，使得多个对象都有机会处理请求，从而避免了请求的发送者与接收者之间的紧耦合。

责任链模式的核心思想是：将请求的处理过程组织成一个链式结构，每个处理节点可以决定是否处理该请求或将其传递给下一个节点。这种模式非常适合处理需要多个条件判断、权限校验、审批流程等场景，能够有效提升系统的灵活性和可扩展性。

本篇文章将从理论到实践全面解析责任链模式，包括其定义、结构、适用场景、实现方式、工作原理、优缺点分析，并结合真实项目案例进行深入探讨。同时，我们还将展示如何在Java中实现责任链模式，并讨论其在Java标准库及主流框架中的应用实例。

模式定义

责任链模式（Chain of Responsibility Pattern） 是一种行为型设计模式，它允许你将请求的发送者与接收者解耦。请求通过一系列处理对象进行传递，直到某个对象决定处理它为止。每个处理对象都包含对下一个处理对象的引用，形成一条链。

该模式的核心思想是：

  • 解耦请求的发送者与接收者
  • 允许多个对象有机会处理请求
  • 动态构建处理链

模式结构

责任链模式由以下几个关键角色组成：

角色 说明
抽象处理者（Handler） 定义处理请求的接口，通常包含一个指向下一个处理者的引用。
具体处理者（Concrete Handler） 实现具体的处理逻辑，决定是否处理请求或将其传递给下一个处理者。
客户端（Client） 创建处理链并发起请求。

类图结构描述：

+----------------+
|   Handler      |
+----------------+
| - next: Handler|
+----------------+
| + setNext()    |
| + handleRequest()|
+----------------+
         ▲
         │
+----------------+
| ConcreteHandlerA|
+----------------+
| + handleRequest()|
+----------------+

         ▲
         │
+----------------+
| ConcreteHandlerB|
+----------------+
| + handleRequest()|
+----------------+

每个具体处理者继承自抽象处理者，维护一个对下一个处理者的引用。当当前处理者无法处理请求时，它会将请求传递给下一个处理者。

适用场景

责任链模式适用于以下典型场景：

场景 说明
多级审批流程 如请假审批、报销申请、合同签署等，不同层级的审批人按顺序处理请求
权限验证 在系统中对用户权限进行逐级验证，如登录、访问控制、操作权限等
日志记录 不同级别的日志信息被不同处理器处理，如调试日志、错误日志、审计日志
过滤器链 Web开发中的过滤器（Filter）、拦截器（Interceptor）等
事件处理 GUI事件、消息队列中的消息处理等

这些场景中，请求的处理可能涉及多个步骤，且处理逻辑具有一定的优先级或顺序性，此时使用责任链模式能有效提高系统的可维护性和可扩展性。

实现方式

下面是一个完整的 Java 示例，演示责任链模式的基本实现。

抽象处理者（Handler）
// 抽象处理者
public abstract class Handler {
    protected Handler next;

    public void setNext(Handler next) {
        this.next = next;
    }

    // 处理请求的方法
    public void handleRequest(Request request) {
        if (canHandle(request)) {
            doHandle(request);
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("No handler can process the request.");
        }
    }

    // 判断是否可以处理该请求
    protected abstract boolean canHandle(Request request);

    // 具体处理逻辑
    protected abstract void doHandle(Request request);
}
具体处理者（Concrete Handler）
// 具体处理者1：处理普通请求
public class ConcreteHandlerA extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getType() == RequestType.NORMAL;
    }

    @Override
    protected void doHandle(Request request) {
        System.out.println("ConcreteHandlerA handled the request: " + request.getMessage());
    }
}

// 具体处理者2：处理紧急请求
public class ConcreteHandlerB extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getType() == RequestType.EMERGENCY;
    }

    @Override
    protected void doHandle(Request request) {
        System.out.println("ConcreteHandlerB handled the request: " + request.getMessage());
    }
}
请求类（Request）
// 请求类
public class Request {
    private RequestType type;
    private String message;

    public Request(RequestType type, String message) {
        this.type = type;
        this.message = message;
    }

    public RequestType getType() {
        return type;
    }

    public String getMessage() {
        return message;
    }
}
枚举类型（RequestType）
// 请求类型枚举
public enum RequestType {
    NORMAL,
    EMERGENCY
}
客户端调用示例
public class Client {
    public static void main(String[] args) {
        // 创建处理链
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNext(handlerB);

        // 发起请求
        Request request1 = new Request(RequestType.NORMAL, "This is a normal request.");
        Request request2 = new Request(RequestType.EMERGENCY, "This is an emergency request.");

        handlerA.handleRequest(request1); // 会被ConcreteHandlerA处理
        handlerA.handleRequest(request2); // 会被ConcreteHandlerB处理
    }
}
单元测试代码（JUnit 5）
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class ChainOfResponsibilityTest {

    @Test
    public void testChainOfResponsibility() {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNext(handlerB);

        Request request1 = new Request(RequestType.NORMAL, "Normal request");
        Request request2 = new Request(RequestType.EMERGENCY, "Emergency request");

        handlerA.handleRequest(request1);
        handlerA.handleRequest(request2);
    }
}

工作原理

责任链模式通过链式结构来传递请求，每个处理者都拥有对下一个处理者的引用。当请求到达链头时，第一个处理者尝试处理，如果不能处理，则将请求传递给下一个处理者，依此类推。

这种方式的优点在于：

  • 请求的发送者不需要知道具体由哪个处理者处理，只需将请求发送到链头即可。
  • 处理链可以动态构建和修改，无需修改请求发送者的代码。
  • 提高了系统的可扩展性，新增处理者只需加入链中，不影响现有逻辑。

优缺点分析

优点 缺点
解耦请求的发送者与接收者 链式结构可能导致调试困难
提高系统的灵活性和可扩展性 请求可能未被任何处理者处理，需注意边界情况
支持动态配置处理链 若链过长，可能影响性能
易于添加新的处理者 需要合理设计处理顺序，否则可能造成逻辑混乱

案例分析：企业审批系统

假设我们正在开发一个企业内部的审批系统，用于处理员工的请假申请。根据请假天数的不同，审批流程也不同：

  • 1天以内：部门经理审批
  • 2~5天：部门经理 + 人事部审批
  • 5天以上：部门经理 + 人事部 + 总经理审批

在这种情况下，使用责任链模式可以很好地组织审批流程，而无需在请求发送者中硬编码审批路径。

代码实现
// 抽象处理者
public abstract class ApprovalHandler {
    protected ApprovalHandler next;

    public void setNext(ApprovalHandler next) {
        this.next = next;
    }

    public void approve(LeaveRequest request) {
        if (canApprove(request)) {
            doApprove(request);
        } else if (next != null) {
            next.approve(request);
        } else {
            System.out.println("No approver can process the request.");
        }
    }

    protected abstract boolean canApprove(LeaveRequest request);
    protected abstract void doApprove(LeaveRequest request);
}

// 具体处理者：部门经理
public class ManagerApprover extends ApprovalHandler {
    @Override
    protected boolean canApprove(LeaveRequest request) {
        return request.getDays() <= 1;
    }

    @Override
    protected void doApprove(LeaveRequest request) {
        System.out.println("Manager approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");
    }
}

// 具体处理者：人事部
public class HRApprover extends ApprovalHandler {
    @Override
    protected boolean canApprove(LeaveRequest request) {
        return request.getDays() > 1 && request.getDays() <= 5;
    }

    @Override
    protected void doApprove(LeaveRequest request) {
        System.out.println("HR approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");
    }
}

// 具体处理者：总经理
public class CEOApprover extends ApprovalHandler {
    @Override
    protected boolean canApprove(LeaveRequest request) {
        return request.getDays() > 5;
    }

    @Override
    protected void doApprove(LeaveRequest request) {
        System.out.println("CEO approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");
    }
}

// 请求类
public class LeaveRequest {
    private String employeeName;
    private int days;

    public LeaveRequest(String employeeName, int days) {
        this.employeeName = employeeName;
        this.days = days;
    }

    public String getEmployeeName() {
        return employeeName;
    }

    public int getDays() {
        return days;
    }
}

// 客户端
public class LeaveApprovalSystem {
    public static void main(String[] args) {
        ApprovalHandler manager = new ManagerApprover();
        ApprovalHandler hr = new HRApprover();
        ApprovalHandler ceo = new CEOApprover();

        manager.setNext(hr);
        hr.setNext(ceo);

        LeaveRequest request1 = new LeaveRequest("Alice", 1);
        LeaveRequest request2 = new LeaveRequest("Bob", 3);
        LeaveRequest request3 = new LeaveRequest("Charlie", 7);

        manager.approve(request1); // 被部门经理处理
        manager.approve(request2); // 被人事部处理
        manager.approve(request3); // 被总经理处理
    }
}

在这个案例中，责任链模式清晰地表达了审批流程的层次结构，使系统更易于维护和扩展。例如，若以后需要增加新的审批级别，只需添加一个新的处理者并将其链接到链中即可。

与其他模式的关系

责任链模式常常与其他设计模式结合使用，以增强其功能或解决更复杂的问题：

模式 关系说明
命令模式（Command Pattern） 命令模式封装请求为对象，责任链模式则处理请求链，二者可以结合使用，实现灵活的请求处理机制
观察者模式（Observer Pattern） 责任链模式关注请求的传递，而观察者模式关注事件的通知，二者可以协同工作，实现事件驱动的系统
策略模式（Strategy Pattern） 责任链模式强调处理链的顺序，而策略模式强调算法的替换，两者可以配合使用，实现不同的处理策略
装饰器模式（Decorator Pattern） 责任链模式和装饰器模式都采用组合方式扩展对象功能，但责任链模式更关注请求的处理流程，而装饰器模式更关注对象的行为增强

总结

今天我们学习了责任链模式的核心思想、结构、适用场景、实现方式、工作原理、优缺点分析，并通过实际项目案例进行了深入讲解。责任链模式通过解耦请求的发送者与接收者，使得多个对象有机会处理请求，提升了系统的灵活性和可扩展性。

在Java中，责任链模式可以通过抽象类和链式引用实现，适用于审批流程、权限验证、日志处理等多种场景。此外，责任链模式还可以与其他设计模式（如命令模式、观察者模式）结合使用，进一步增强系统的功能和可维护性。

下一天我们将进入“设计模式精讲”的第14天，讲解命令模式（Command Pattern），敬请期待！

文章标签

design-patterns, java, software-architecture, oop, chain-of-responsibility

文章简述

本文详细介绍了设计模式中的责任链模式（Chain of Responsibility Pattern），通过理论与实践结合的方式，帮助Java开发工程师理解其核心思想、实现方式以及应用场景。文章提供了完整的Java代码示例，展示了如何构建责任链结构，并通过企业审批系统的真实案例说明其实际价值。责任链模式通过解耦请求的发送者与接收者，提高了系统的灵活性和可扩展性，特别适合多级审批、权限验证、日志处理等场景。本文不仅涵盖了模式的基本概念，还深入分析了其与其它设计模式的关系，并提供了单元测试代码，确保读者能够直接应用到实际项目中。

进一步学习资料

  1. Design Patterns: Elements of Reusable Object-Oriented Software
  2. Refactoring Guru - Chain of Responsibility
  3. Java Design Patterns - Chain of Responsibility
  4. Martin Fowler’s Patterns of Enterprise Application Architecture
  5. Head First Design Patterns

核心设计思想总结

  • 责任链模式通过链式结构传递请求，实现解耦与灵活处理
  • 适用于多级审批、权限验证、日志处理等场景
  • 在Java中可通过抽象类和链式引用实现
  • 应避免链过长导致性能问题，注意边界条件处理
  • 可与其他设计模式（如命令模式、观察者模式）结合使用

希望本文能帮助你在实际项目中更好地理解和应用责任链模式，提升系统的设计质量与可维护性。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布