【设计模式精讲 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 {@Overrideprotected boolean canHandle(Request request) {return request.getType() == RequestType.NORMAL;}@Overrideprotected void doHandle(Request request) {System.out.println("ConcreteHandlerA handled the request: " + request.getMessage());}
}// 具体处理者2：处理紧急请求
public class ConcreteHandlerB extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getType() == RequestType.EMERGENCY;}@Overrideprotected 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 {@Testpublic 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 {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() <= 1;}@Overrideprotected void doApprove(LeaveRequest request) {System.out.println("Manager approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");}
}// 具体处理者：人事部
public class HRApprover extends ApprovalHandler {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() > 1 && request.getDays() <= 5;}@Overrideprotected void doApprove(LeaveRequest request) {System.out.println("HR approved: " + request.getEmployeeName() + " for " + request.getDays() + " days.");}
}// 具体处理者：总经理
public class CEOApprover extends ApprovalHandler {@Overrideprotected boolean canApprove(LeaveRequest request) {return request.getDays() > 5;}@Overrideprotected 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代码示例，展示了如何构建责任链结构，并通过企业审批系统的真实案例说明其实际价值。责任链模式通过解耦请求的发送者与接收者，提高了系统的灵活性和可扩展性，特别适合多级审批、权限验证、日志处理等场景。本文不仅涵盖了模式的基本概念，还深入分析了其与其它设计模式的关系，并提供了单元测试代码，确保读者能够直接应用到实际项目中。