责任链模式：请求处理的流水线

bicheng/2025/10/3 8:58:49/文章来源:href="https://blog.51cto.com/u_16587128/14100595" target="_blank"

责任链模式：请求处理的流水线

摘要

责任链模式（Chain of Responsibility Pattern）是行为型设计模式中的"请求传递专家"，它通过构建处理对象的链来解耦请求的发送者和接收者。本文将全面剖析责任链模式的核心概念、实现方式、应用场景及高级变体，通过丰富的Java代码示例展示如何构建灵活的处理流水线，并分析其与状态模式、策略模式的区别与适用场景。

一、责任链模式核心思想

责任链模式的核心是构建处理链，具有以下关键特征：

链式处理：多个处理对象形成处理链
动态配置：可灵活调整处理链顺序
解耦发送者与接收者：发送者无需知道具体处理者
处理可终止：任一处理者可终止处理流程

适用场景：

多个对象可以处理同一请求但具体处理者未知
需要动态指定处理请求的对象集合
需要按顺序传递请求直到被处理
希望在不明确指定接收者的情况下向多个对象发送请求

二、责任链模式结构解析

UML类图示意

[Handler] <|-- [ConcreteHandlerA]
[Handler] <|-- [ConcreteHandlerB]
[Handler] o--> [Handler]

核心组件角色

角色	职责	典型实现
Handler	处理者接口	定义处理请求的接口
ConcreteHandler	具体处理者	实现处理逻辑，维护后继者
Client	客户端	创建处理链并触发请求

三、基础实现：审批流程案例

// 审批请求
class ApprovalRequest {private String requestId;private String requestType;private double amount;public ApprovalRequest(String requestId, String requestType, double amount) {this.requestId = requestId;this.requestType = requestType;this.amount = amount;}// getters...
}// 审批处理器接口
interface Approver {void setNextApprover(Approver nextApprover);void processRequest(ApprovalRequest request);
}// 具体审批者：经理
class Manager implements Approver {private Approver nextApprover;private static final double APPROVAL_LIMIT = 5000;@Overridepublic void setNextApprover(Approver nextApprover) {this.nextApprover = nextApprover;}@Overridepublic void processRequest(ApprovalRequest request) {if (request.getAmount() <= APPROVAL_LIMIT) {System.out.println("Manager approves request " + request.getRequestId());} else if (nextApprover != null) {nextApprover.processRequest(request);} else {System.out.println("Request " + request.getRequestId() + " requires higher approval");}}
}// 具体审批者：总监
class Director implements Approver {private Approver nextApprover;private static final double APPROVAL_LIMIT = 20000;@Overridepublic void setNextApprover(Approver nextApprover) {this.nextApprover = nextApprover;}@Overridepublic void processRequest(ApprovalRequest request) {if (request.getAmount() <= APPROVAL_LIMIT) {System.out.println("Director approves request " + request.getRequestId());} else if (nextApprover != null) {nextApprover.processRequest(request);} else {System.out.println("Request " + request.getRequestId() + " requires executive approval");}}
}// 具体审批者：副总裁
class VicePresident implements Approver {private static final double APPROVAL_LIMIT = 50000;@Overridepublic void setNextApprover(Approver nextApprover) {// 副总裁是最高审批者，无后继者}@Overridepublic void processRequest(ApprovalRequest request) {if (request.getAmount() <= APPROVAL_LIMIT) {System.out.println("Vice President approves request " + request.getRequestId());} else {System.out.println("Request " + request.getRequestId() + " requires board approval");}}
}// 客户端使用
public class ApprovalSystem {public static void main(String[] args) {// 构建责任链Approver manager = new Manager();Approver director = new Director();Approver vp = new VicePresident();manager.setNextApprover(director);director.setNextApprover(vp);// 创建审批请求ApprovalRequest request1 = new ApprovalRequest("REQ001", "Travel", 3000);ApprovalRequest request2 = new ApprovalRequest("REQ002", "Equipment", 15000);ApprovalRequest request3 = new ApprovalRequest("REQ003", "Conference", 45000);ApprovalRequest request4 = new ApprovalRequest("REQ004", "Bonus", 60000);// 处理请求manager.processRequest(request1);manager.processRequest(request2);manager.processRequest(request3);manager.processRequest(request4);}
}

四、高级应用：Web请求过滤器链

1. 基础过滤器实现

// 过滤器接口
interface Filter {void doFilter(HttpRequest request, HttpResponse response, FilterChain chain);
}// 过滤器链
class FilterChain {private List<Filter> filters = new ArrayList<>();private int index = 0;public FilterChain addFilter(Filter filter) {filters.add(filter);return this;}public void doFilter(HttpRequest request, HttpResponse response) {if (index < filters.size()) {Filter filter = filters.get(index++);filter.doFilter(request, response, this);} else {// 所有过滤器处理完毕，执行业务逻辑processBusiness(request, response);}}private void processBusiness(HttpRequest request, HttpResponse response) {System.out.println("Processing business logic for " + request.getPath());response.setStatus(200);response.setBody("Request processed successfully");}
}// 具体过滤器：认证过滤器
class AuthenticationFilter implements Filter {@Overridepublic void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) {System.out.println("Authenticating request...");if (request.getHeader("Authorization") == null) {response.setStatus(401);response.setBody("Unauthorized");} else {chain.doFilter(request, response);}}
}// 具体过滤器：日志过滤器
class LoggingFilter implements Filter {@Overridepublic void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) {System.out.println("Logging request: " + request.getMethod() + " " + request.getPath());long startTime = System.currentTimeMillis();chain.doFilter(request, response);long duration = System.currentTimeMillis() - startTime;System.out.println("Request processed in " + duration + "ms");}
}// 具体过滤器：缓存过滤器
class CacheFilter implements Filter {private Map<String, HttpResponse> cache = new HashMap<>();@Overridepublic void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) {String cacheKey = request.getMethod() + ":" + request.getPath();if (cache.containsKey(cacheKey)) {System.out.println("Returning cached response");HttpResponse cachedResponse = cache.get(cacheKey);response.copyFrom(cachedResponse);} else {chain.doFilter(request, response);if (response.getStatus() == 200) {cache.put(cacheKey, response.copy());}}}
}// 使用示例
public class WebServer {public static void main(String[] args) {FilterChain chain = new FilterChain().addFilter(new LoggingFilter()).addFilter(new AuthenticationFilter()).addFilter(new CacheFilter());HttpRequest request = new HttpRequest("GET", "/api/users", Map.of("Authorization", "Bearer token123"));HttpResponse response = new HttpResponse();chain.doFilter(request, response);System.out.println("Final response: " + response.getStatus());}
}

2. Spring Security过滤器链

// 模拟Spring Security的过滤器链
class SecurityFilterChain {private List<SecurityFilter> filters;public SecurityFilterChain(List<SecurityFilter> filters) {this.filters = new ArrayList<>(filters);}public void doFilterInternal(HttpServletRequest request, HttpServletResponse response) throws IOException {VirtualFilterChain virtualChain = new VirtualFilterChain(filters);virtualChain.doFilter(request, response);}private static class VirtualFilterChain {private final List<SecurityFilter> additionalFilters;private int currentPosition = 0;public VirtualFilterChain(List<SecurityFilter> additionalFilters) {this.additionalFilters = additionalFilters;}public void doFilter(HttpServletRequest request, HttpServletResponse response) throws IOException {if (currentPosition == additionalFilters.size()) {// 执行实际请求处理return;}currentPosition++;SecurityFilter nextFilter = additionalFilters.get(currentPosition - 1);nextFilter.doFilter(request, response, this);}}
}interface SecurityFilter {void doFilter(HttpServletRequest request, HttpServletResponse response,SecurityFilterChain chain) throws IOException;
}// 具体安全过滤器
class CsrfFilter implements SecurityFilter {public void doFilter(HttpServletRequest request, HttpServletResponse response,SecurityFilterChain chain) throws IOException {String csrfToken = request.getHeader("X-CSRF-TOKEN");if (csrfToken == null || !isValidCsrfToken(csrfToken)) {response.sendError(403, "Invalid CSRF token");return;}chain.doFilter(request, response);}private boolean isValidCsrfToken(String token) {// 验证逻辑...return true;}
}class CorsFilter implements SecurityFilter {public void doFilter(HttpServletRequest request, HttpServletResponse response,SecurityFilterChain chain) throws IOException {response.setHeader("Access-Control-Allow-Origin", "*");response.setHeader("Access-Control-Allow-Methods", "GET, POST");chain.doFilter(request, response);}
}

五、责任链模式优缺点分析

优点：

优点	说明
解耦发送者与接收者	发送者无需知道具体处理者
动态配置处理链	可灵活调整处理顺序
单一职责原则	每个处理者只关注自己责任范围
开闭原则	新增处理者不影响现有代码

缺点：

缺点	说明
请求可能未被处理	链中没有合适处理者
性能影响	长链可能导致处理延迟
调试困难	请求传递路径不易跟踪
循环引用风险	处理链形成循环

六、责任链模式与其他模式对比

责任链模式 vs 装饰器模式

维度	责任链模式	装饰器模式
目的	处理请求直到被处理	动态添加职责
控制流	可终止传递	必须传递到所有装饰器
关注点	请求处理	对象增强
典型应用	审批流程、过滤器	IO流、UI组件

责任链模式 vs 状态模式

维度	责任链模式	状态模式
目的	传递请求到合适处理者	对象行为随状态改变
处理者关系	相互独立	状态相互了解
变化点	处理链配置	状态转换
典型应用	工作流处理	订单状态管理

七、责任链模式最佳实践

1. 责任链构建器

class ChainBuilder<T> {private List<Handler<T>> handlers = new ArrayList<>();public ChainBuilder<T> addHandler(Handler<T> handler) {handlers.add(handler);return this;}public Handler<T> build() {if (handlers.isEmpty()) {throw new IllegalStateException("No handlers added");}for (int i = 0; i < handlers.size() - 1; i++) {handlers.get(i).setNext(handlers.get(i + 1));}return handlers.get(0);}
}// 使用示例
Handler<ApprovalRequest> approvalChain = new ChainBuilder<ApprovalRequest>().addHandler(new Manager()).addHandler(new Director()).addHandler(new VicePresident()).build();approvalChain.handleRequest(new ApprovalRequest("REQ005", "Training", 8000));

2. 功能组合责任链

// 组合多个责任链
class CompositeChain<T> implements Handler<T> {private List<Handler<T>> chains = new ArrayList<>();public void addChain(Handler<T> chain) {chains.add(chain);}@Overridepublic void handleRequest(T request) {for (Handler<T> chain : chains) {chain.handleRequest(request);}}
}// 使用示例
CompositeChain<HttpRequest> httpChains = new CompositeChain<>();
httpChains.addChain(buildSecurityChain());
httpChains.addChain(buildLoggingChain());
httpChains.addChain(buildMonitoringChain());httpChains.handleRequest(request);

3. 中断标记责任链

// 带中断标记的处理结果
class ProcessingResult {private boolean shouldContinue;private Object response;public ProcessingResult(boolean shouldContinue, Object response) {this.shouldContinue = shouldContinue;this.response = response;}// getters...
}// 改进的处理器接口
interface InterruptibleHandler<T, R> {ProcessingResult<R> handle(T request);void setNext(InterruptibleHandler<T, R> next);
}// 改进的责任链
class InterruptibleChain<T, R> {private InterruptibleHandler<T, R> firstHandler;public InterruptibleChain(InterruptibleHandler<T, R>... handlers) {if (handlers.length == 0) {throw new IllegalArgumentException("At least one handler required");}this.firstHandler = handlers[0];for (int i = 0; i < handlers.length - 1; i++) {handlers[i].setNext(handlers[i + 1]);}}public ProcessingResult<R> execute(T request) {return firstHandler.handle(request);}
}

八、责任链模式在开源框架中的应用

Java Servlet过滤器

// Servlet过滤器是责任链模式的典型实现
@WebFilter("/*")
public class LoggingFilter implements Filter {public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out.println("Before request processing");long startTime = System.currentTimeMillis();chain.doFilter(request, response); // 传递到下一个过滤器long duration = System.currentTimeMillis() - startTime;System.out.println("Request processed in " + duration + "ms");}
}@WebFilter("/secure/*")
public class AuthenticationFilter implements Filter {public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;if (httpRequest.getSession(false) == null) {((HttpServletResponse)response).sendError(401);return; // 中断链}chain.doFilter(request, response);}
}

Spring MVC拦截器

// HandlerInterceptor是责任链模式的变体
public class LogInterceptor implements HandlerInterceptor {public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {// 返回true继续链，false中断return true;}public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {// 处理完成后执行}
}// 配置拦截器链
@Configuration
public class WebConfig implements WebMvcConfigurer {public void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new LogInterceptor());registry.addInterceptor(new AuthInterceptor());registry.addInterceptor(new PerformanceInterceptor());}
}

九、高级应用：动态可配置责任链

1. 规则引擎责任链

// 基于规则的责任链
class RuleEngine {private List<Rule> rules = new ArrayList<>();public void addRule(Rule rule) {rules.add(rule);}public Object evaluate(Facts facts) {for (Rule rule : rules) {if (rule.matches(facts)) {return rule.execute(facts);}}throw new NoApplicableRuleException();}
}interface Rule {boolean matches(Facts facts);Object execute(Facts facts);
}// 使用示例
RuleEngine engine = new RuleEngine();
engine.addRule(new DiscountRule());
engine.addRule(new TaxRule());
engine.addRule(new ShippingRule());Facts orderFacts = new Facts(order);
Object result = engine.evaluate(orderFacts);

2. 工作流引擎责任链

// 可配置的工作流责任链
class WorkflowEngine {private Map<String, Workflow> workflows = new HashMap<>();public void registerWorkflow(String name, Workflow workflow) {workflows.put(name, workflow);}public void executeWorkflow(String name, Context context) {Workflow workflow = workflows.get(name);if (workflow != null) {workflow.execute(context);}}
}class Workflow {private List<WorkflowStep> steps = new ArrayList<>();public void addStep(WorkflowStep step) {steps.add(step);}public void execute(Context context) {for (WorkflowStep step : steps) {if (!step.execute(context)) {break; // 步骤可中断流程}}}
}interface WorkflowStep {boolean execute(Context context);
}

十、责任链模式未来发展趋势

新兴应用方向：

微服务编排：服务调用链式管理
函数式编程：组合函数形成处理链
事件溯源：事件处理责任链
AI决策流水线：AI模型链式调用
区块链智能合约：合约执行链

响应式责任链

// Reactor中的责任链
Flux<String> processingChain = Flux.just("request").flatMap(this::step1).flatMap(this::step2).flatMap(this::step3).onErrorResume(this::handleError);processingChain.subscribe(result -> System.out.println("Processed: " + result),error -> System.err.println("Error: " + error)
);Mono<String> step1(String input) {return Mono.fromCallable(() -> {// 处理步骤1return input + " processed by step1";});
}