当前位置： 首页 > news >正文

设计模式-责任链模式详解

news 2025/9/24 9:39:58

责任链模式详解

目录

  1. 责任链模式简介
  2. 核心流程
  3. 重难点分析
  4. Spring中的源码分析
  5. 具体使用场景
  6. 面试高频点
  7. 使用总结

责任链模式简介

定义

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

核心思想

  • 解耦发送者和接收者：请求发送者不需要知道具体哪个对象处理请求
  • 动态链式处理：可以在运行时动态构建处理链
  • 灵活配置：可以灵活添加、删除、修改处理节点
  • 单一职责：每个处理者只负责处理自己能处理的请求

模式结构

  • Handler（抽象处理者）：定义处理请求的接口，实现后继链
  • ConcreteHandler（具体处理者）：处理它所负责的请求，可访问它的后继者
  • Client（客户端）：向链上的具体处理者对象提交请求

核心流程

责任链模式流程图

请求处理
处理链
是
否
是
否
是
否
请求验证
业务处理
结果返回
处理者1
处理者2
处理者3
处理者N
客户端发送请求
第一个处理者
能否处理?
处理请求
传递给下一个处理者
是否有下一个处理者?
下一个处理者
无法处理请求
能否处理?
返回处理结果
返回无法处理

基本实现流程

1. 定义抽象处理者
// 抽象处理者
public abstract class Handler {protected Handler nextHandler;public void setNext(Handler nextHandler) {this.nextHandler = nextHandler;}public Handler getNext() {return nextHandler;}// 处理请求的抽象方法public abstract void handleRequest(Request request);// 模板方法：定义处理流程public final void process(Request request) {if (canHandle(request)) {handleRequest(request);} else if (nextHandler != null) {nextHandler.process(request);} else {System.out.println("无法处理请求: " + request);}}// 判断是否能处理请求protected abstract boolean canHandle(Request request);
}
2. 定义请求类
// 请求类
public 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;}// getter和setter方法public String getType() { return type; }public void setType(String type) { this.type = type; }public String getContent() { return content; }public void setContent(String content) { this.content = content; }public int getLevel() { return level; }public void setLevel(int level) { this.level = level; }@Overridepublic String toString() {return "Request{" +"type='" + type + '\'' +", content='" + content + '\'' +", level=" + level +'}';}
}
3. 实现具体处理者
// 具体处理者 - 初级处理者
public class JuniorHandler extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getLevel() <= 1;}@Overridepublic void handleRequest(Request request) {System.out.println("初级处理者处理请求: " + request);}
}// 具体处理者 - 中级处理者
public class MiddleHandler extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getLevel() <= 3;}@Overridepublic void handleRequest(Request request) {System.out.println("中级处理者处理请求: " + request);}
}// 具体处理者 - 高级处理者
public class SeniorHandler extends Handler {@Overrideprotected boolean canHandle(Request request) {return request.getLevel() <= 5;}@Overridepublic void handleRequest(Request request) {System.out.println("高级处理者处理请求: " + request);}
}
4. 客户端使用
public class Client {public static void main(String[] args) {// 创建处理者Handler junior = new JuniorHandler();Handler middle = new MiddleHandler();Handler senior = new SeniorHandler();// 构建责任链junior.setNext(middle);middle.setNext(senior);// 创建请求Request request1 = new Request("简单请求", "处理简单问题", 1);Request request2 = new Request("复杂请求", "处理复杂问题", 4);Request request3 = new Request("困难请求", "处理困难问题", 6);// 处理请求junior.process(request1);junior.process(request2);junior.process(request3);}
}

重难点分析

重难点1：责任链的构建和管理

问题描述

如何动态构建和管理责任链，支持链的添加、删除、修改。

解决方案
// 责任链管理器
public class ChainManager {private Handler firstHandler;private Handler lastHandler;private List<Handler> handlers = new ArrayList<>();public ChainManager addHandler(Handler handler) {if (firstHandler == null) {firstHandler = handler;lastHandler = handler;} else {lastHandler.setNext(handler);lastHandler = handler;}handlers.add(handler);return this;}public ChainManager removeHandler(Handler handler) {if (handlers.remove(handler)) {rebuildChain();}return this;}public ChainManager insertHandler(Handler handler, int index) {if (index < 0 || index > handlers.size()) {throw new IllegalArgumentException("索引超出范围");}handlers.add(index, handler);rebuildChain();return this;}private void rebuildChain() {firstHandler = null;lastHandler = null;for (Handler handler : handlers) {if (firstHandler == null) {firstHandler = handler;lastHandler = handler;} else {lastHandler.setNext(handler);lastHandler = handler;}}}public void process(Request request) {if (firstHandler != null) {firstHandler.process(request);} else {System.out.println("责任链为空，无法处理请求");}}public List<Handler> getHandlers() {return new ArrayList<>(handlers);}
}// 使用示例
public class ChainManagerDemo {public static void main(String[] args) {ChainManager manager = new ChainManager();// 添加处理者manager.addHandler(new JuniorHandler()).addHandler(new MiddleHandler()).addHandler(new SeniorHandler());// 处理请求Request request = new Request("测试请求", "测试内容", 2);manager.process(request);// 动态添加处理者manager.addHandler(new EmergencyHandler());// 处理紧急请求Request emergencyRequest = new Request("紧急请求", "紧急内容", 10);manager.process(emergencyRequest);}
}

重难点2：责任链的终止条件

问题描述

如何设置责任链的终止条件，避免无限循环。

解决方案
// 带终止条件的责任链
public abstract class TerminableHandler extends Handler {protected boolean terminated = false;public void setTerminated(boolean terminated) {this.terminated = terminated;}public boolean isTerminated() {return terminated;}@Overridepublic final void process(Request request) {if (terminated) {System.out.println("责任链已终止，无法处理请求");return;}if (canHandle(request)) {handleRequest(request);// 处理完成后可以选择终止链if (shouldTerminate(request)) {terminated = true;}} else if (nextHandler != null) {nextHandler.process(request);} else {System.out.println("无法处理请求: " + request);}}// 子类可以重写此方法决定是否终止链protected boolean shouldTerminate(Request request) {return false;}
}// 具体处理者实现
public class TerminableJuniorHandler extends TerminableHandler {@Overrideprotected boolean canHandle(Request request) {return request.getLevel() <= 1;}@Overridepublic void handleRequest(Request request) {System.out.println("初级处理者处理请求: " + request);}@Overrideprotected boolean shouldTerminate(Request request) {// 处理紧急请求后终止链return "紧急".equals(request.getType());}
}

重难点3：责任链的性能优化

问题描述

如何优化责任链的性能，避免不必要的处理。

解决方案
// 带缓存的责任链
public class CachedHandler extends Handler {private final Map<String, Handler> handlerCache = new ConcurrentHashMap<>();private final Map<String, Boolean> canHandleCache = new ConcurrentHashMap<>();@Overridepublic void process(Request request) {String requestKey = generateRequestKey(request);// 检查缓存Boolean canHandle = canHandleCache.get(requestKey);if (canHandle == null) {canHandle = canHandle(request);canHandleCache.put(requestKey, canHandle);}if (canHandle) {handleRequest(request);} else if (nextHandler != null) {nextHandler.process(request);} else {System.out.println("无法处理请求: " + request);}}private String generateRequestKey(Request request) {return request.getType() + "_" + request.getLevel();}public void clearCache() {handlerCache.clear();canHandleCache.clear();}
}// 并行处理的责任链
public class ParallelHandler extends Handler {private final ExecutorService executor = Executors.newFixedThreadPool(10);@Overridepublic void process(Request request) {if (canHandle(request)) {// 并行处理CompletableFuture.runAsync(() -> handleRequest(request), executor);} else if (nextHandler != null) {nextHandler.process(request);} else {System.out.println("无法处理请求: " + request);}}public void shutdown() {executor.shutdown();}
}

重难点4：责任链的异常处理

问题描述

如何在责任链中处理异常，确保链的稳定性。

解决方案
// 带异常处理的责任链
public abstract class ExceptionHandler extends Handler {@Overridepublic final void process(Request request) {try {if (canHandle(request)) {handleRequest(request);} else if (nextHandler != null) {nextHandler.process(request);} else {System.out.println("无法处理请求: " + request);}} catch (Exception e) {handleException(request, e);}}protected void handleException(Request request, Exception e) {System.out.println("处理请求时发生异常: " + e.getMessage());// 可以选择继续传递给下一个处理者if (nextHandler != null) {nextHandler.process(request);}}
}// 具体处理者实现
public class ExceptionHandlingHandler extends ExceptionHandler {@Overrideprotected boolean canHandle(Request request) {return request.getLevel() <= 2;}@Overridepublic void handleRequest(Request request) {// 模拟可能抛出异常的处理if (request.getContent().contains("异常")) {throw new RuntimeException("处理异常");}System.out.println("处理请求: " + request);}
}

Spring中的源码分析

Spring MVC的HandlerInterceptor

// HandlerInterceptor接口
public interface HandlerInterceptor {default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {}default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}
}// HandlerInterceptorAdapter
public abstract class HandlerInterceptorAdapter implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
}// HandlerExecutionChain
public class HandlerExecutionChain {private final Object handler;private HandlerInterceptor[] interceptors;private List<HandlerInterceptor> interceptorList;private int interceptorIndex = -1;public HandlerExecutionChain(Object handler) {this(handler, (HandlerInterceptor[]) null);}public HandlerExecutionChain(Object handler, @Nullable HandlerInterceptor... interceptors) {this.handler = handler;this.interceptors = interceptors;}public void addInterceptor(HandlerInterceptor interceptor) {initInterceptorList();this.interceptorList.add(interceptor);updateInterceptorsArray();}public void addInterceptor(int index, HandlerInterceptor interceptor) {initInterceptorList();this.interceptorList.add(index, interceptor);updateInterceptorsArray();}public boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {HandlerInterceptor[] interceptors = getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for (int i = 0; i < interceptors.length; i++) {HandlerInterceptor interceptor = interceptors[i];if (!interceptor.preHandle(request, response, this.handler)) {triggerAfterCompletion(request, response, null);return false;}this.interceptorIndex = i;}}return true;}public void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {HandlerInterceptor[] interceptors = getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for (int i = interceptors.length - 1; i >= 0; i--) {HandlerInterceptor interceptor = interceptors[i];interceptor.postHandle(request, response, this.handler, mv);}}}public void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {HandlerInterceptor[] interceptors = getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for (int i = this.interceptorIndex; i >= 0; i--) {HandlerInterceptor interceptor = interceptors[i];try {interceptor.afterCompletion(request, response, this.handler, ex);} catch (Throwable ex2) {logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);}}}}
}

Spring Security的FilterChain

// FilterChainProxy
public class FilterChainProxy extends GenericFilterBean {private List<SecurityFilterChain> filterChains;private FilterChainValidator filterChainValidator = new NullFilterChainValidator();private HttpFirewall firewall = new StrictHttpFirewall();@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {boolean clearContext = request.getAttribute(FILTER_APPLIED) == null;if (clearContext) {try {request.setAttribute(FILTER_APPLIED, Boolean.TRUE);doFilterInternal(request, response, chain);} finally {SecurityContextHolder.clearContext();request.removeAttribute(FILTER_APPLIED);}} else {doFilterInternal(request, response, chain);}}private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {FirewalledRequest firewallRequest = this.firewall.getFirewalledRequest((HttpServletRequest) request);HttpServletResponse firewallResponse = this.firewall.getFirewalledResponse((HttpServletResponse) response);List<Filter> filters = getFilters(firewallRequest);if (filters == null || filters.size() == 0) {firewallRequest.reset();chain.doFilter(firewallRequest, firewallResponse);return;}VirtualFilterChain virtualFilterChain = new VirtualFilterChain(firewallRequest, chain, filters);virtualFilterChain.doFilter(firewallRequest, firewallResponse);}private List<Filter> getFilters(HttpServletRequest request) {for (SecurityFilterChain chain : filterChains) {if (chain.matches(request)) {return chain.getFilters();}}return null;}
}// VirtualFilterChain
private static class VirtualFilterChain implements FilterChain {private final FilterChain originalChain;private final List<Filter> additionalFilters;private final FirewalledRequest firewalledRequest;private final int size;private int currentPosition = 0;private VirtualFilterChain(FirewalledRequest firewalledRequest, FilterChain originalChain, List<Filter> additionalFilters) {this.firewalledRequest = firewalledRequest;this.originalChain = originalChain;this.additionalFilters = additionalFilters;this.size = additionalFilters.size();}@Overridepublic void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {if (currentPosition == size) {if (logger.isDebugEnabled()) {logger.debug(UrlUtils.buildRequestUrl(firewalledRequest) + " reached end of additional filter chain; proceeding with original chain");}originalChain.doFilter(request, response);} else {currentPosition++;Filter nextFilter = additionalFilters.get(currentPosition - 1);if (logger.isDebugEnabled()) {logger.debug(UrlUtils.buildRequestUrl(firewalledRequest) + " at position " + currentPosition + " of " + size + " in additional filter chain; firing Filter: '" + nextFilter.getClass().getSimpleName() + "'");}nextFilter.doFilter(request, response, this);}}
}

具体使用场景

1. 权限验证链

// 权限验证处理器
public abstract class PermissionHandler {protected PermissionHandler nextHandler;public void setNext(PermissionHandler nextHandler) {this.nextHandler = nextHandler;}public boolean checkPermission(User user, String resource) {if (canHandle(user, resource)) {return handlePermission(user, resource);} else if (nextHandler != null) {return nextHandler.checkPermission(user, resource);} else {return false;}}protected abstract boolean canHandle(User user, String resource);protected abstract boolean handlePermission(User user, String resource);
}// 角色权限验证
public class RolePermissionHandler extends PermissionHandler {@Overrideprotected boolean canHandle(User user, String resource) {return user.getRole() != null;}@Overrideprotected boolean handlePermission(User user, String resource) {return user.getRole().hasPermission(resource);}
}// 资源权限验证
public class ResourcePermissionHandler extends PermissionHandler {@Overrideprotected boolean canHandle(User user, String resource) {return resource.startsWith("/admin/");}@Overrideprotected boolean handlePermission(User user, String resource) {return user.isAdmin();}
}// 时间权限验证
public class TimePermissionHandler extends PermissionHandler {@Overrideprotected boolean canHandle(User user, String resource) {return resource.startsWith("/time/");}@Overrideprotected boolean handlePermission(User user, String resource) {LocalTime now = LocalTime.now();return now.isAfter(LocalTime.of(9, 0)) && now.isBefore(LocalTime.of(18, 0));}
}// 使用示例
public class PermissionChainDemo {public static void main(String[] args) {// 创建权限验证链PermissionHandler roleHandler = new RolePermissionHandler();PermissionHandler resourceHandler = new ResourcePermissionHandler();PermissionHandler timeHandler = new TimePermissionHandler();roleHandler.setNext(resourceHandler);resourceHandler.setNext(timeHandler);// 创建用户User user = new User("admin", "ADMIN");// 验证权限boolean hasPermission1 = roleHandler.checkPermission(user, "/user/profile");boolean hasPermission2 = roleHandler.checkPermission(user, "/admin/users");boolean hasPermission3 = roleHandler.checkPermission(user, "/time/report");System.out.println("用户权限验证结果:");System.out.println("/user/profile: " + hasPermission1);System.out.println("/admin/users: " + hasPermission2);System.out.println("/time/report: " + hasPermission3);}
}

2. 日志处理链

// 日志处理器
public abstract class LogHandler {protected LogHandler nextHandler;public void setNext(LogHandler nextHandler) {this.nextHandler = nextHandler;}public void handleLog(LogEntry logEntry) {if (canHandle(logEntry)) {processLog(logEntry);}if (nextHandler != null) {nextHandler.handleLog(logEntry);}}protected abstract boolean canHandle(LogEntry logEntry);protected abstract void processLog(LogEntry logEntry);
}// 控制台日志处理器
public class ConsoleLogHandler extends LogHandler {@Overrideprotected boolean canHandle(LogEntry logEntry) {return logEntry.getLevel().ordinal() >= LogLevel.INFO.ordinal();}@Overrideprotected void processLog(LogEntry logEntry) {System.out.println("控制台日志: " + logEntry);}
}// 文件日志处理器
public class FileLogHandler extends LogHandler {@Overrideprotected boolean canHandle(LogEntry logEntry) {return logEntry.getLevel().ordinal() >= LogLevel.WARN.ordinal();}@Overrideprotected void processLog(LogEntry logEntry) {System.out.println("文件日志: " + logEntry);}
}// 邮件日志处理器
public class EmailLogHandler extends LogHandler {@Overrideprotected boolean canHandle(LogEntry logEntry) {return logEntry.getLevel() == LogLevel.ERROR;}@Overrideprotected void processLog(LogEntry logEntry) {System.out.println("邮件日志: " + logEntry);}
}// 使用示例
public class LogChainDemo {public static void main(String[] args) {// 创建日志处理链LogHandler consoleHandler = new ConsoleLogHandler();LogHandler fileHandler = new FileLogHandler();LogHandler emailHandler = new EmailLogHandler();consoleHandler.setNext(fileHandler);fileHandler.setNext(emailHandler);// 处理日志LogEntry infoLog = new LogEntry(LogLevel.INFO, "系统启动");LogEntry warnLog = new LogEntry(LogLevel.WARN, "内存不足");LogEntry errorLog = new LogEntry(LogLevel.ERROR, "数据库连接失败");consoleHandler.handleLog(infoLog);consoleHandler.handleLog(warnLog);consoleHandler.handleLog(errorLog);}
}

3. 订单处理链

// 订单处理器
public abstract class OrderHandler {protected OrderHandler nextHandler;public void setNext(OrderHandler nextHandler) {this.nextHandler = nextHandler;}public void processOrder(Order order) {if (canHandle(order)) {handleOrder(order);}if (nextHandler != null) {nextHandler.processOrder(order);}}protected abstract boolean canHandle(Order order);protected abstract void handleOrder(Order order);
}// 库存验证处理器
public class InventoryHandler extends OrderHandler {@Overrideprotected boolean canHandle(Order order) {return true; // 所有订单都需要验证库存}@Overrideprotected void handleOrder(Order order) {if (order.getItems().stream().allMatch(item -> item.getStock() >= item.getQuantity())) {System.out.println("库存验证通过: " + order.getId());} else {System.out.println("库存不足: " + order.getId());order.setStatus(OrderStatus.CANCELLED);}}
}// 支付处理处理器
public class PaymentHandler extends OrderHandler {@Overrideprotected boolean canHandle(Order order) {return order.getStatus() != OrderStatus.CANCELLED;}@Overrideprotected void handleOrder(Order order) {if (order.getPaymentMethod().isValid()) {System.out.println("支付处理成功: " + order.getId());order.setStatus(OrderStatus.PAID);} else {System.out.println("支付处理失败: " + order.getId());order.setStatus(OrderStatus.PAYMENT_FAILED);}}
}// 发货处理处理器
public class ShippingHandler extends OrderHandler {@Overrideprotected boolean canHandle(Order order) {return order.getStatus() == OrderStatus.PAID;}@Overrideprotected void handleOrder(Order order) {System.out.println("开始发货: " + order.getId());order.setStatus(OrderStatus.SHIPPED);}
}// 使用示例
public class OrderChainDemo {public static void main(String[] args) {// 创建订单处理链OrderHandler inventoryHandler = new InventoryHandler();OrderHandler paymentHandler = new PaymentHandler();OrderHandler shippingHandler = new ShippingHandler();inventoryHandler.setNext(paymentHandler);paymentHandler.setNext(shippingHandler);// 创建订单Order order = new Order("ORDER001", Arrays.asList(new OrderItem("ITEM001", 2, 10),new OrderItem("ITEM002", 1, 20)), new PaymentMethod("CARD", "1234567890"));// 处理订单inventoryHandler.processOrder(order);System.out.println("订单状态: " + order.getStatus());}
}

面试高频点

面试知识点思维导图

责任链模式面试点
基本概念
实现方式
重难点
Spring应用
设计原则
实际应用
解耦发送者和接收者
动态链式处理
灵活配置
单一职责
Handler抽象处理者
ConcreteHandler具体处理者
Client客户端
Request请求类
责任链构建管理
终止条件设置
性能优化
异常处理
HandlerInterceptor
FilterChain
SecurityFilterChain
AOP切面链
单一职责
开闭原则
依赖倒置
接口隔离
权限验证链
日志处理链
订单处理链
异常处理链

1. 责任链模式的基本概念

问题：什么是责任链模式？

答案要点：

  • 多个对象都有机会处理请求，避免请求发送者和接收者之间的耦合
  • 将这些对象连成一条链，沿着链传递请求
  • 属于行为型设计模式
  • 直到有一个对象处理请求为止
问题：责任链模式有哪些角色？

答案要点：

  • Handler（抽象处理者）：定义处理请求的接口，实现后继链
  • ConcreteHandler（具体处理者）：处理它所负责的请求，可访问它的后继者
  • Client（客户端）：向链上的具体处理者对象提交请求

2. 实现方式相关

问题：如何实现责任链模式？

答案要点：

// 1. 定义抽象处理者
public abstract class Handler {protected Handler nextHandler;public void setNext(Handler nextHandler) {this.nextHandler = nextHandler;}public abstract void handleRequest(Request request);
}// 2. 实现具体处理者
public class ConcreteHandler extends Handler {@Overridepublic void handleRequest(Request request) {if (canHandle(request)) {// 处理请求} else if (nextHandler != null) {nextHandler.handleRequest(request);}}protected abstract boolean canHandle(Request request);
}

3. 重难点问题

问题：如何设置责任链的终止条件？

答案要点：

  • 检查下一个处理者：如果nextHandler为null，则链结束
  • 处理结果控制：根据处理结果决定是否继续传递
  • 异常处理：异常情况下可以终止链
  • 业务逻辑控制：根据业务需求设置终止条件
问题：责任链模式的性能如何优化？

答案要点：

// 1. 缓存处理结果
public class CachedHandler extends Handler {private final Map<String, Boolean> cache = new ConcurrentHashMap<>();@Overridepublic void handleRequest(Request request) {String key = generateKey(request);Boolean canHandle = cache.computeIfAbsent(key, k -> canHandle(request));if (canHandle) {// 处理请求} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}// 2. 并行处理
public class ParallelHandler extends Handler {private final ExecutorService executor = Executors.newFixedThreadPool(10);@Overridepublic void handleRequest(Request request) {if (canHandle(request)) {executor.submit(() -> processRequest(request));} else if (nextHandler != null) {nextHandler.handleRequest(request);}}
}

4. Spring中的应用

问题：Spring中如何使用责任链模式？

答案要点：

// 1. HandlerInterceptor链
public class CustomInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {// 预处理逻辑return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {// 后处理逻辑}
}// 2. Filter链
public class CustomFilter implements Filter {@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {// 处理逻辑chain.doFilter(request, response);}
}

5. 设计原则相关

问题：责任链模式体现了哪些设计原则？

答案要点：

  • 单一职责：每个处理者只负责处理自己能处理的请求
  • 开闭原则：可以添加新的处理者而不修改现有代码
  • 依赖倒置：依赖抽象而不是具体实现
  • 接口隔离：客户端只依赖需要的接口

6. 实际应用场景

问题：责任链模式适用于哪些场景？

答案要点：

  • 权限验证：多级权限验证
  • 日志处理：多级日志处理
  • 订单处理：订单处理流程
  • 异常处理：多级异常处理
  • 请求处理：Web请求处理链
  • 数据验证：多级数据验证

使用总结

责任链模式的优势

  1. 解耦：请求发送者和接收者解耦
  2. 灵活配置：可以动态添加、删除、修改处理者
  3. 单一职责：每个处理者只负责自己的职责
  4. 可扩展性：易于添加新的处理者

责任链模式的缺点

  1. 性能问题：链式调用可能影响性能
  2. 调试困难：链式调用使调试变得困难
  3. 循环依赖：可能出现循环依赖问题
  4. 内存开销：链式调用占用额外内存

使用建议

  1. 简单场景：只用于简单的处理场景
  2. 性能考虑：注意链式调用的性能影响
  3. 异常处理：做好异常处理，避免链中断
  4. 测试覆盖：确保每个处理者都有测试覆盖

最佳实践

  1. 明确职责：每个处理者职责明确
  2. 异常处理：做好异常处理机制
  3. 性能优化：考虑缓存和并行处理
  4. 文档注释：为每个处理者添加详细注释
  5. 单元测试：为每个处理者编写单元测试

与其他模式的对比

  1. 与装饰器模式：责任链模式是链式处理，装饰器模式是包装处理
  2. 与策略模式：责任链模式是链式选择，策略模式是单一选择
  3. 与命令模式：责任链模式是处理请求，命令模式是封装请求

责任链模式是一种有用的行为型设计模式，特别适用于需要多级处理、权限验证、日志处理等场景。通过合理使用责任链模式，可以大大提高系统的灵活性和可维护性。

http://www.dtcms.com/a/399094.html

相关文章：

  • CentOS7安装mysql最简单教程
  • 垂直网站建设方案南庄建网站服务
  • 【LVS入门宝典】LVS DR模式深度解析：直接路由（DR）的高性能秘诀，MAC地址欺骗与ARP隔离
  • 自做网站视频潍坊免费网站制作
  • 代理通讯篇无外网或不可达SockS全协议规则配置C2正反向上线解决方案
  • 做网站麻烦吗网页创意与设计50例
  • 建筑公司网站需求h5个人网站代码
  • Qwen-image-edit在ComfyUI部署使用
  • 跨云镜像迁移实战：阿里云 → 腾讯云
  • 二、更新源（阿里云）（更新成阿里云后，再执行上面的系统更新）
  • 域名访问网站怎么下载书籍设计网站推荐
  • Playwright UI自动化实战速成指南
  • 【11408学习记录】考研数学线性代数核心突破：初等变换与初等矩阵完全攻略
  • 两学一做知识竞赛试题网站怎样做营销型网站推广ppt
  • 在HTTP请求上运行SQLMap靶机（打靶记录）
  • 全球外贸网站排名wordpress 媒体播放
  • wordpress 多站点配置文件市场调研公司是做什么业务的
  • Linux/Ubuntu 终端常用压缩工具XZ/BZip2/Gzip
  • 做网站的应用公司做网站要花多少钱
  • 医药行业从OCR到IDP的应用延申
  • 想自己做点飘纱素材到网站上买网站友情链接连接
  • 企业级一体化信创DevOps平台选型指南：如何平衡效率、安全与合规？
  • 网站页面打开速度哈尔滨网站营销推广
  • python+spingboot+vue学生宿舍报修及缴费系统 故障报修 工单处理 在线缴费查询 后勤服务管理平台 报修申请+缴费记录+维修进度跟踪系统
  • 汽车网络安全 CyberSecurity ISO/SAE 21434 测试之三
  • 超级分享 局域网文件互传 Easy Share WiFi File Transfer v1.5.22 解锁高级会员版
  • Redis 监听过期Key
  • 随身WiFi二合一设备开发深度解析：Wi-Fi 6模块集成与三网切换算法优化
  • 国内做外单的网站有哪些200元网站建设
  • 口碑好的江苏网站建设wix做的网站在国内访问不