一、设计模式概述
1.1 核心思想
责任链模式允许将多个对象连接成一条链，请求沿着这条链传递，直到有一个对象处理它为止。这种模式避免了请求发送者和接收者之间的耦合关系，使多个对象都有机会处理请求。
1.2 UML类图结构
复制
┌─────────────────┐ ┌─────────────────┐
│ Handler │<>----│ Handler │
├─────────────────┤ ├─────────────────┤
│- successor │ │+ handleRequest()│
├─────────────────┤ └─────────────────┘
│+ setSuccessor() │ △
│+ handleRequest()│ │
└─────────────────┘ ┌───────┴───────┐
△ │ │
│ ┌─────────┐ ┌─────────┐
│ │Concrete │ │Concrete │
│ │Handler1 │ │Handler2 │
│ └─────────┘ └─────────┘
┌─────────────────┐
│ Client │
└─────────────────┘
二、完整Java代码实现
2.1 基本责任链模式实现
java
java
下载
复制
// 1. 请求类
class Request {
private String type;
private String content;
private int level; // 请求级别
public Request(String type, String content, int level) {
this.type = type;
this.content = content;
this.level = level;
}
public String getType() { return type; }
public String getContent() { return content; }
public int getLevel() { return level; }
}
// 2. 处理者抽象类
abstract class Handler {
protected Handler nextHandler;
protected String name;
public Handler(String name) {
this.name = name;
}
// 设置下一个处理者
public Handler setNext(Handler nextHandler) {
this.nextHandler = nextHandler;
return nextHandler; // 支持链式调用
}
// 处理请求
public final void handleRequest(Request request) {
if (canHandle(request)) {
process(request);
} else if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
System.out.println("没有合适的处理器处理此请求: " + request.getContent());
}
}
// 判断是否能处理
protected abstract boolean canHandle(Request request);
// 处理逻辑
protected abstract void process(Request request);
}
// 3. 具体处理者实现
class JuniorManager extends Handler {
public JuniorManager(String name) {
super(name);
}
@Override
protected boolean canHandle(Request request) {
return request.getLevel() <= 1; // 初级经理处理1级及以下请求
}
@Override
protected void process(Request request) {
System.out.println("初级经理 [" + name + "] 处理请求: " + request.getContent());
}
}
class SeniorManager extends Handler {
public SeniorManager(String name) {
super(name);
}
@Override
protected boolean canHandle(Request request) {
return request.getLevel() <= 3; // 高级经理处理3级及以下请求
}
@Override
protected void process(Request request) {
System.out.println("高级经理 [" + name + "] 处理请求: " + request.getContent());
}
}
class GeneralManager extends Handler {
public GeneralManager(String name) {
super(name);
}
@Override
protected boolean canHandle(Request request) {
return request.getLevel() <= 5; // 总经理处理所有请求
}
@Override
protected void process(Request request) {
System.out.println("总经理 [" + name + "] 处理请求: " + request.getContent());
}
}
// 4. 客户端使用
public class ChainOfResponsibilityDemo {
public static void main(String[] args) {
// 创建处理者链
Handler junior = new JuniorManager("张三");
Handler senior = new SeniorManager("李四");
Handler general = new GeneralManager("王五");
// 构建责任链
junior.setNext(senior).setNext(general);
// 创建请求
Request[] requests = {
new Request("请假", "请假3天", 1),
new Request("采购", "采购办公用品", 3),
new Request("预算", "年度预算审批", 5),
new Request("紧急", "紧急事故处理", 6)
};
// 处理请求
for (Request request : requests) {
System.out.println("\n处理请求: " + request.getContent() + " (级别: " + request.getLevel() + ")");
junior.handleRequest(request);
}
}
}
2.2 更灵活的链构建方式
java
java
下载
复制
// 链构建器
class HandlerChain {
private Handler head;
private Handler tail;
public HandlerChain addHandler(Handler handler) {
if (head == null) {
head = handler;
tail = handler;
} else {
tail.setNext(handler);
tail = handler;
}
return this;
}
public void handle(Request request) {
if (head != null) {
head.handleRequest(request);
} else {
System.out.println("处理链为空");
}
}
}
// 使用链构建器
class ChainBuilderDemo {
public static void main(String[] args) {
HandlerChain chain = new HandlerChain()
.addHandler(new JuniorManager("张三"))
.addHandler(new SeniorManager("李四"))
.addHandler(new GeneralManager("王五"));
chain.handle(new Request("请假", "请假5天", 2));
}
}
2.3 带拦截器和后处理的增强版
java
java
下载
复制
// 增强的处理者接口
interface EnhancedHandler {
boolean handle(HandlerContext context);
int getOrder(); // 处理顺序
}
// 处理上下文
class HandlerContext {
private Request request;
private Map<String, Object> attributes = new HashMap<>();
private List<String> processLog = new ArrayList<>();
private boolean stopChain = false;
public HandlerContext(Request request) {
this.request = request;
}
public Request getRequest() { return request; }
public Map<String, Object> getAttributes() { return attributes; }
public List<String> getProcessLog() { return processLog; }
public boolean isStopChain() { return stopChain; }
public void stopChain() { this.stopChain = true; }
public void addLog(String message) {
processLog.add("[" + System.currentTimeMillis() + "] " + message);
}
}
// 责任链执行器
class ChainExecutor {
private List<EnhancedHandler> handlers = new ArrayList<>();
public void addHandler(EnhancedHandler handler) {
handlers.add(handler);
handlers.sort(Comparator.comparingInt(EnhancedHandler::getOrder));
}
public boolean execute(HandlerContext context) {
for (EnhancedHandler handler : handlers) {
context.addLog("开始执行处理器: " + handler.getClass().getSimpleName());
boolean processed = handler.handle(context);
if (processed || context.isStopChain()) {
context.addLog("处理器链终止于: " + handler.getClass().getSimpleName());
return true;
}
}
return false;
}
}
三、应用场景分析
3.1 Web框架中的过滤器链
java
java
下载
复制
// Servlet过滤器链示例
@WebFilter("/*")
class LoggingFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
long start = System.currentTimeMillis();
chain.doFilter(request, response); // 传递到下一个过滤器
long end = System.currentTimeMillis();
System.out.println("请求处理时间: " + (end - start) + "ms");
}
}
@WebFilter("/*")
class AuthenticationFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
if (isAuthenticated(httpRequest)) {
chain.doFilter(request, response);
} else {
((HttpServletResponse) response).sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
}
private boolean isAuthenticated(HttpServletRequest request) {
// 认证逻辑
return true;
}
}
3.2 审批工作流系统
java
java
下载
复制
// 多级审批工作流
abstract class ApprovalHandler {
protected ApprovalHandler next;
protected String role;
protected double maxAmount; // 最大审批金额
public void setNext(ApprovalHandler next) { this.next = next; }
public void process(ApprovalRequest request) {
if (canApprove(request)) {
approve(request);
} else if (next != null) {
next.process(request);
} else {
reject(request);
}
}
protected boolean canApprove(ApprovalRequest request) {
return request.getAmount() <= maxAmount;
}
protected abstract void approve(ApprovalRequest request);
protected abstract void reject(ApprovalRequest request);
}
class DepartmentManager extends ApprovalHandler {
public DepartmentManager() {
this.role = "部门经理";
this.maxAmount = 10000;
}
@Override
protected void approve(ApprovalRequest request) {
System.out.println(role + " 批准了申请: " + request.getDescription());
request.setStatus("已批准");
request.setApprover(role);
}
@Override
protected void reject(ApprovalRequest request) {
System.out.println(role + " 驳回了申请: " + request.getDescription());
request.setStatus("已驳回");
}
}
3.3 实际应用场景
- Web框架 - Servlet过滤器、Spring拦截器
- 日志处理 - Log4j、Logback的Appender链
- 异常处理 - 多层异常捕获和处理
- 事件处理 - GUI事件传播机制
- 中间件 - 消息处理管道
- 权限验证 - 多层权限检查
- 数据处理管道 - ETL数据转换流程
- 游戏开发 - 输入事件处理链
- 工作流引擎 - 多级审批流程
- 网络协议栈 - 协议层处理
四、优缺点深度分析
4.1 优点
✅ 降低耦合度：发送者无需知道哪个对象处理请求
✅ 增强灵活性：可动态改变链中处理者的顺序或增加新处理者
✅ 简化对象：每个处理者只需关注自己的工作，无需关注链结构
✅ 符合开闭原则：新增处理者无需修改现有代码
✅ 责任分配明确：每个处理者职责单一
✅ 可配置性高：可运行时配置处理链
4.2 缺点
❌ 请求可能不被处理：请求可能到达链尾仍未被处理
❌ 性能问题：长链可能导致处理延迟
❌ 调试困难：请求处理路径不明确，调试复杂
❌ 循环引用风险：链配置不当可能形成循环
❌ 请求处理顺序依赖：处理顺序可能影响结果
❌ 内存泄漏风险：长生命周期链可能持有对象引用
五、改进与优化方向
5.1 带中断和跳转的增强链
java
java
下载
复制
// 支持中断和跳转的责任链
class AdvancedHandlerChain {
private List<Handler> handlers = new ArrayList<>();
private int current = 0;
public void addHandler(Handler handler) {
handlers.add(handler);
}
public boolean handle(Request request) {
while (current < handlers.size()) {
Handler handler = handlers.get(current);
ProcessResult result = handler.process(request);
switch (result.getAction()) {
case CONTINUE:
current++;
break;
case BREAK:
return true; // 中断处理
case JUMP_TO:
int jumpIndex = result.getJumpToIndex();
if (jumpIndex >= 0 && jumpIndex < handlers.size()) {
current = jumpIndex;
} else {
current++;
}
break;
case RESTART:
current = 0;
break;
}
}
return false;
}
enum Action { CONTINUE, BREAK, JUMP_TO, RESTART }
class ProcessResult {
private Action action;
private int jumpToIndex = -1;
// 构造方法和getter
}
}
5.2 异步责任链
java
java
下载
复制
// 异步处理链
class AsyncHandlerChain {
private List<AsyncHandler> handlers = new ArrayList<>();
private ExecutorService executor = Executors.newFixedThreadPool(4);
public void addHandler(AsyncHandler handler) {
handlers.add(handler);
}
public CompletableFuture<Boolean> handleAsync(Request request) {
CompletableFuture<Boolean> future = CompletableFuture.completedFuture(false);
for (AsyncHandler handler : handlers) {
future = future.thenCompose(processed -> {
if (processed) {
return CompletableFuture.completedFuture(true);
}
return handler.handleAsync(request);
});
}
return future;
}
}
interface AsyncHandler {
CompletableFuture<Boolean> handleAsync(Request request);
}
5.3 可监控的责任链
java
java
下载
复制
// 带监控和统计的责任链
class MonitoredHandlerChain {
private List<Handler> handlers = new ArrayList<>();
private Map<String, HandlerStats> stats = new ConcurrentHashMap<>();
public void addHandler(Handler handler) {
handlers.add(handler);
stats.put(handler.getName(), new HandlerStats());
}
public boolean handle(Request request) {
long chainStart = System.currentTimeMillis();
boolean processed = false;
for (Handler handler : handlers) {
HandlerStats handlerStats = stats.get(handler.getName());
long handlerStart = System.currentTimeMillis();
try {
processed = handler.handle(request);
handlerStats.recordSuccess(System.currentTimeMillis() - handlerStart);
if (processed) {
break;
}
} catch (Exception e) {
handlerStats.recordFailure(System.currentTimeMillis() - handlerStart, e);
throw e;
}
}
long totalTime = System.currentTimeMillis() - chainStart;
System.out.println("责任链处理总时间: " + totalTime + "ms");
return processed;
}
static class HandlerStats {
private AtomicLong successCount = new AtomicLong();
private AtomicLong failureCount = new AtomicLong();
private AtomicLong totalTime = new AtomicLong();
public void recordSuccess(long time) {
successCount.incrementAndGet();
totalTime.addAndGet(time);
}
public void recordFailure(long time, Exception e) {
failureCount.incrementAndGet();
totalTime.addAndGet(time);
}
public double getAverageTime() {
long count = successCount.get() + failureCount.get();
return count > 0 ? (double) totalTime.get() / count : 0;
}
}
}
5.4 条件责任链
java
java
下载
复制
// 基于条件的责任链路由
class ConditionalHandlerChain {
private List<HandlerNode> nodes = new ArrayList<>();
public void addHandler(Predicate<Request> condition, Handler handler) {
nodes.add(new HandlerNode(condition, handler));
}
public boolean handle(Request request) {
for (HandlerNode node : nodes) {
if (node.condition.test(request)) {
return node.handler.handle(request);
}
}
return false;
}
static class HandlerNode {
Predicate<Request> condition;
Handler handler;
HandlerNode(Predicate<Request> condition, Handler handler) {
this.condition = condition;
this.handler = handler;
}
}
}
六、注意事项与最佳实践
6.1 防止链过长
java
java
下载
复制
// 链长度限制
class LimitedHandlerChain {
private List<Handler> handlers = new ArrayList<>();
private int maxChainLength = 10;
public void addHandler(Handler handler) {
if (handlers.size() >= maxChainLength) {
throw new IllegalStateException("处理链过长，最大允许" + maxChainLength + "个处理器");
}
handlers.add(handler);
}
public boolean handle(Request request) {
int depth = 0;
Handler current = (handlers.isEmpty()) ? null : handlers.get(0);
while (current != null && depth < maxChainLength) {
if (current.handle(request)) {
return true;
}
current = current.getNext();
depth++;
}
if (depth >= maxChainLength) {
System.err.println("警告: 处理链深度达到限制");
}
return false;
}
}
6.2 避免循环引用
java
java
下载
复制
// 循环引用检测
class CycleSafeHandlerChain {
private List<Handler> handlers = new ArrayList<>();
public void addHandler(Handler handler) {
// 检查是否形成循环
if (createsCycle(handler)) {
throw new IllegalArgumentException("添加此处理器会形成循环引用");
}
handlers.add(handler);
}
private boolean createsCycle(Handler newHandler) {
Set<Handler> visited = new HashSet<>();
Handler current = newHandler;
while (current != null) {
if (visited.contains(current)) {
return true; // 检测到循环
}
visited.add(current);
current = current.getNext();
}
return false;
}
}
6.3 资源清理
java
java
下载
复制
// 带资源清理的责任链
class ResourceAwareHandlerChain implements AutoCloseable {
private List<Handler> handlers = new ArrayList<>();
private List<AutoCloseable> closeableResources = new ArrayList<>();
public void addHandler(Handler handler) {
handlers.add(handler);
if (handler instanceof AutoCloseable) {
closeableResources.add((AutoCloseable) handler);
}
}
@Override
public void close() throws Exception {
List<Exception> exceptions = new ArrayList<>();
// 反向关闭，类似栈的顺序
for (int i = closeableResources.size() - 1; i >= 0; i--) {
try {
closeableResources.get(i).close();
} catch (Exception e) {
exceptions.add(e);
}
}
if (!exceptions.isEmpty()) {
Exception ex = new Exception("关闭资源时发生多个异常");
exceptions.forEach(ex::addSuppressed);
throw ex;
}
}
}
七、高级责任链模式
7.1 组合责任链
java
java
下载
复制
// 多层嵌套责任链
class CompositeHandler implements Handler {
private HandlerChain internalChain = new HandlerChain();
public CompositeHandler addInternalHandler(Handler handler) {
internalChain.addHandler(handler);
return this;
}
@Override
public boolean handle(Request request) {
System.out.println("组合处理器开始处理...");
// 预处理
if (!preHandle(request)) {
return false;
}
// 内部链处理
boolean processed = internalChain.handle(request);
// 后处理
postHandle(request, processed);
return processed;
}
protected boolean preHandle(Request request) {
// 预处理逻辑
return true;
}
protected void postHandle(Request request, boolean processed) {
// 后处理逻辑
System.out.println("组合处理器处理完成，结果: " + processed);
}
}
7.2 责任链工厂
java
java
下载
复制
// 责任链工厂模式
class HandlerChainFactory {
public static Handler createStandardChain() {
Handler validation = new ValidationHandler();
Handler authentication = new AuthenticationHandler();
Handler authorization = new AuthorizationHandler();
Handler business = new BusinessHandler();
Handler logging = new LoggingHandler();
validation.setNext(authentication)
.setNext(authorization)
.setNext(business)
.setNext(logging);
return validation;
}
public static Handler createFastChain() {
Handler validation = new ValidationHandler();
Handler business = new BusinessHandler();
validation.setNext(business);
return validation;
}
public static Handler createChainFromConfig(String configFile) {
// 从配置文件创建链
List<Handler> handlers = loadHandlersFromConfig(configFile);
if (handlers.isEmpty()) {
return new DefaultHandler();
}
Handler first = handlers.get(0);
Handler current = first;
for (int i = 1; i < handlers.size(); i++) {
current.setNext(handlers.get(i));
current = handlers.get(i);
}
return first;
}
}
八、实际应用示例
8.1 Spring框架中的责任链
java
java
下载
复制
// Spring拦截器链
@Component
class LoggingInterceptor extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
request.setAttribute("startTime", System.currentTimeMillis());
return true; // 继续链
}
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response,
Object handler, Exception ex) throws Exception {
long startTime = (Long) request.getAttribute("startTime");
long duration = System.currentTimeMillis() - startTime;
System.out.println("请求耗时: " + duration + "ms");
}
}
// Spring Security过滤器链配置
@Configuration
@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.addFilterBefore(new LoggingFilter(), UsernamePasswordAuthenticationFilter.class)
.addFilterAfter(new CorsFilter(), LoggingFilter.class)
.addFilterAt(new CustomFilter(), BasicAuthenticationFilter.class)
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated();
}
}
8.2 Netty中的责任链
java
java
下载
复制
// Netty ChannelPipeline责任链
public class NettyServer {
public static void main(String[] args) {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ChannelPipeline pipeline = ch.pipeline();
// 添加处理器到责任链
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast("handler", new BusinessHandler());
// 可以动态添加/移除处理器
pipeline.addAfter("decoder", "logging", new LoggingHandler());
}
});
ChannelFuture f = b.bind(8080).sync();
f.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
九、与其他模式的关系
9.1 与装饰器模式结合
java
java
下载
复制
// 责任链 + 装饰器模式
abstract class HandlerDecorator implements Handler {
protected Handler wrapped;
public HandlerDecorator(Handler wrapped) {
this.wrapped = wrapped;
}
@Override
public boolean handle(Request request) {
if (wrapped != null) {
return wrapped.handle(request);
}
return false;
}
}
// 缓存装饰器
class CachingHandlerDecorator extends HandlerDecorator {
private Map<Request, Boolean> cache = new ConcurrentHashMap<>();
public CachingHandlerDecorator(Handler wrapped) {
super(wrapped);
}
@Override
public boolean handle(Request request) {
return cache.computeIfAbsent(request, req -> {
System.out.println("缓存未命中，实际处理请求: " + req.getContent());
return super.handle(req);
});
}
}
9.2 与策略模式结合
java
java
下载
复制
// 责任链 + 策略模式
class StrategyBasedHandler implements Handler {
private Map<String, ProcessingStrategy> strategies = new HashMap<>();
private ProcessingStrategy defaultStrategy;
public StrategyBasedHandler() {
// 注册策略
strategies.put("type1", new Type1Strategy());
strategies.put("type2", new Type2Strategy());
defaultStrategy = new DefaultStrategy();
}
@Override
public boolean handle(Request request) {
ProcessingStrategy strategy = strategies.getOrDefault(
request.getType(), defaultStrategy
);
return strategy.process(request);
}
}
interface ProcessingStrategy {
boolean process(Request request);
}
十、性能优化与监控
10.1 责任链性能监控
java
java
下载
复制
// 性能监控的责任链
class ProfilingHandlerChain {
private List<Handler> handlers = new ArrayList<>();
private HandlerStatistics stats = new HandlerStatistics();
public void addHandler(Handler handler) {
handlers.add(new ProfilingHandlerWrapper(handler, stats));
}
public boolean handle(Request request) {
long startTime = System.nanoTime();
try {
for (Handler handler : handlers) {
if (handler.handle(request)) {
return true;
}
}
return false;
} finally {
long duration = System.nanoTime() - startTime;
stats.recordChainDuration(duration);
}
}
public void printStatistics() {
stats.print();
}
}
class HandlerStatistics {
private Map<String, Long> handlerTimes = new ConcurrentHashMap<>();
private AtomicLong chainTime = new AtomicLong();
private AtomicInteger totalRequests = new AtomicInteger();
public void recordHandlerTime(String handlerName, long nanos) {
handlerTimes.merge(handlerName, nanos, Long::sum);
}
public void recordChainDuration(long nanos) {
chainTime.addAndGet(nanos);
totalRequests.incrementAndGet();
}
public void print() {
System.out.println("=== 责任链统计 ===");
System.out.println("总请求数: " + totalRequests.get());
System.out.println("总链处理时间: " + chainTime.get() / 1_000_000 + "ms");
System.out.println("平均每请求: " + chainTime.get() / totalRequests.get() + "ns");
handlerTimes.forEach((name, time) -> {
System.out.println(name + ": " + time / 1_000_000 + "ms");
});
}
}
总结
责任链模式是处理请求处理流程的经典模式，特别适用于需要多个对象按顺序处理请求的场景。它在Web框架、中间件、工作流系统中广泛应用。
关键实践要点：
- 明确处理顺序：确保链的顺序符合业务逻辑
- 处理链终止条件：必须有明确的终止条件避免无限循环
- 性能监控：长链需要性能监控和优化
- 错误处理：合理处理处理器中的异常
- 资源管理：及时释放处理器持有的资源
- 避免循环引用：特别注意链的配置
现代框架中的最佳实践：
- 使用注解或配置定义处理器和顺序
- 支持异步处理提高吞吐量
- 提供监控和统计功能
- 支持热更新处理链配置
- 实现熔断和降级机制
责任链模式体现了单一职责原则和开闭原则，是构建灵活、可扩展处理流程的重要工具。正确使用可以显著提高代码的可维护性和可扩展性。
