责任链模式，请求传递的智能分发器！

想象一下，你在公司申请报销，需要经过直属领导 → 部门经理 → 财务总监 → 总经理的层层审批。每一级都有自己的权限范围，超出权限就传给下一级。责任链模式就像给你的代码装了这样一套"智能审批系统"，让请求能够在处理器链中自动流转，找到最合适的处理者！

🤔 什么是责任链模式？

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它让你能够将请求沿着处理者链进行传递。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。

说人话就是：把多个处理器串成一条链，请求像接力棒一样在链上传递，直到找到能处理它的那个！

生活中的责任链模式

公司审批流程就是最好的例子：

请假申请流程：
员工申请 → 直属主管(≤3天) → 部门经理(≤7天) → HR总监(≤15天) → 总经理(>15天)

每一级都有处理权限，超出权限就往上传！

客服系统：

客户投诉处理：
AI机器人 → 一线客服 → 高级客服 → 客服主管 → 客服经理

从简单到复杂，层层递进！

医院看病流程：

病人就诊：
挂号 → 护士初诊 → 医生诊断 → 专家会诊 → 科室主任

每个环节都有自己的职责范围！

异常处理：

程序异常处理：
try-catch → 全局异常处理器 → 日志记录器 → 告警系统

异常像皮球一样被踢来踢去，直到有人能处理！

💼 责任链模式的应用场景

1. Web开发中的过滤器链

// Servlet Filter链
请求 → 认证过滤器 → 权限过滤器 → 日志过滤器 → 业务处理器

2. 审批工作流

// OA系统审批流程
申请 → 直属领导 → 部门经理 → 分管副总 → 总经理

3. 异常处理机制

// 多级异常处理
业务异常 → 业务处理器 → 系统异常处理器 → 默认处理器

4. 中间件处理管道

// Express.js中间件
请求 → 日志中间件 → 认证中间件 → 业务中间件 → 响应

⚙️ 责任链模式的核心原理

核心组件

1. 抽象处理者（Handler）：定义处理请求的接口，包含指向下一个处理者的引用
2. 具体处理者（ConcreteHandler）：实现处理逻辑，决定能否处理请求
3. 客户端（Client）：创建责任链，向链的第一个处理者发送请求

代码实现：公司审批系统

1. 审批请求类

/**
 * 审批请求 - 封装请求信息
 */
public class ApprovalRequest {
    
    private String requestId;           // 请求ID
    private String applicant;           // 申请人
    private String type;                // 请求类型
    private double amount;              // 金额
    private String description;         // 描述
    private String reason;              // 申请原因
    private ApprovalStatus status;      // 审批状态
    private String approver;            // 审批人
    private String approvalComment;     // 审批意见
    private long submitTime;            // 提交时间
    
    public ApprovalRequest(String requestId, String applicant, String type, 
                          double amount, String description, String reason) {
        this.requestId = requestId;
        this.applicant = applicant;
        this.type = type;
        this.amount = amount;
        this.description = description;
        this.reason = reason;
        this.status = ApprovalStatus.PENDING;
        this.submitTime = System.currentTimeMillis();
    }
    
    // Getters and Setters
    public String getRequestId() { return requestId; }
    public String getApplicant() { return applicant; }
    public String getType() { return type; }
    public double getAmount() { return amount; }
    public String getDescription() { return description; }
    public String getReason() { return reason; }
    
    public ApprovalStatus getStatus() { return status; }
    public void setStatus(ApprovalStatus status) { this.status = status; }
    
    public String getApprover() { return approver; }
    public void setApprover(String approver) { this.approver = approver; }
    
    public String getApprovalComment() { return approvalComment; }
    public void setApprovalComment(String comment) { this.approvalComment = comment; }
    
    public long getSubmitTime() { return submitTime; }
    
    @Override
    public String toString() {
        return String.format("ApprovalRequest{ID='%s', 申请人='%s', 类型='%s', " +
                           "金额=%.2f, 状态=%s, 审批人='%s'}",
                           requestId, applicant, type, amount, status, approver);
    }
}

/**
 * 审批状态枚举
 */
public enum ApprovalStatus {
    PENDING("待审批"),
    APPROVED("已通过"),
    REJECTED("已拒绝"),
    CANCELLED("已取消");
    
    private String description;
    
    ApprovalStatus(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return description;
    }
}

2. 抽象审批处理者

/**
 * 抽象审批处理者 - 责任链模式的核心抽象类
 */
public abstract class ApprovalHandler {
    
    protected ApprovalHandler nextHandler;  // 下一个处理者
    protected String handlerName;           // 处理者名称
    protected double maxAmount;             // 最大审批权限
    
    public ApprovalHandler(String handlerName, double maxAmount) {
        this.handlerName = handlerName;
        this.maxAmount = maxAmount;
    }
    
    /**
     * 设置下一个处理者
     */
    public ApprovalHandler setNext(ApprovalHandler nextHandler) {
        this.nextHandler = nextHandler;
        return nextHandler; // 支持链式调用
    }
    
    /**
     * 处理审批请求 - 模板方法
     */
    public final void handleRequest(ApprovalRequest request) {
        System.out.println("\n" + "=".repeat(50));
        System.out.println("📋 " + handlerName + " 开始处理审批请求");
        System.out.println("请求信息：" + request);
        System.out.println("处理者权限：最大 " + maxAmount + " 元");
        
        try {
            // 检查是否能够处理
            if (canHandle(request)) {
                System.out.println("✅ " + handlerName + " 有权限处理此请求");
                
                // 执行具体的审批逻辑
                boolean approved = doApproval(request);
                
                if (approved) {
                    request.setStatus(ApprovalStatus.APPROVED);
                    request.setApprover(handlerName);
                    System.out.println("🎉 审批通过！审批人：" + handlerName);
                } else {
                    request.setStatus(ApprovalStatus.REJECTED);
                    request.setApprover(handlerName);
                    System.out.println("❌ 审批拒绝！审批人：" + handlerName);
                }
                
                // 记录审批日志
                logApproval(request);
                
            } else {
                System.out.println("⚠️ " + handlerName + " 权限不足，传递给上级处理");
                
                // 传递给下一个处理者
                if (nextHandler != null) {
                    System.out.println("🔄 传递给：" + nextHandler.handlerName);
                    nextHandler.handleRequest(request);
                } else {
                    System.out.println("❌ 没有更高级别的审批者，请求无法处理");
                    request.setStatus(ApprovalStatus.REJECTED);
                    request.setApprovalComment("超出所有审批者权限范围");
                }
            }
            
        } catch (Exception e) {
            System.err.println("💥 审批过程中发生异常：" + e.getMessage());
            request.setStatus(ApprovalStatus.REJECTED);
            request.setApprovalComment("系统异常：" + e.getMessage());
        }
        
        System.out.println("=".repeat(50));
    }
    
    /**
     * 判断是否能够处理请求
     */
    protected boolean canHandle(ApprovalRequest request) {
        return request.getAmount() <= maxAmount;
    }
    
    /**
     * 具体的审批逻辑 - 抽象方法，由子类实现
     */
    protected abstract boolean doApproval(ApprovalRequest request);
    
    /**
     * 记录审批日志
     */
    protected void logApproval(ApprovalRequest request) {
        System.out.println("📝 审批日志：");
        System.out.println("   审批人：" + handlerName);
        System.out.println("   审批时间：" + new java.util.Date());
        System.out.println("   审批结果：" + request.getStatus().getDescription());
        if (request.getApprovalComment() != null) {
            System.out.println("   审批意见：" + request.getApprovalComment());
        }
    }
    
    /**
     * 获取处理者信息
     */
    public String getHandlerInfo() {
        return handlerName + "(权限: " + maxAmount + "元)";
    }
}

3. 具体审批处理者

/**
 * 直属主管 - 具体处理者
 */
public class DirectSupervisor extends ApprovalHandler {
    
    public DirectSupervisor(String name) {
        super("直属主管-" + name, 1000.0);
    }
    
    @Override
    protected boolean doApproval(ApprovalRequest request) {
        System.out.println("🔍 直属主管审批逻辑：");
        
        // 直属主管的审批逻辑：主要检查申请的合理性
        if (request.getType().equals("请假") && request.getAmount() == 0) {
            request.setApprovalComment("请假申请已批准");
            return true;
        }
        
        if (request.getAmount() <= 500) {
            // 小额申请，简单审批
            System.out.println("   小额申请，快速审批");
            request.setApprovalComment("小额申请，直属主管批准");
            return true;
        } else {
            // 较大金额，严格审批
            System.out.println("   检查申请原因和必要性");
            if (request.getReason() != null && request.getReason().length() > 10) {
                request.setApprovalComment("申请理由充分，直属主管批准");
                return true;
            } else {
                request.setApprovalComment("申请理由不够充分，请补充详细说明");
                return false;
            }
        }
    }
}

/**
 * 部门经理 - 具体处理者
 */
public class DepartmentManager extends ApprovalHandler {
    
    public DepartmentManager(String name) {
        super("部门经理-" + name, 5000.0);
    }
    
    @Override
    protected boolean doApproval(ApprovalRequest request) {
        System.out.println("🔍 部门经理审批逻辑：");
        
        // 部门经理审批逻辑：考虑部门预算和业务需要
        if (request.getType().equals("设备采购")) {
            System.out.println("   设备采购需要评估业务价值");
            if (request.getAmount() <= 3000) {
                request.setApprovalComment("设备采购有助于提升工作效率，部门经理批准");
                return true;
            } else {
                request.setApprovalComment("设备采购金额较大，需要更仔细的评估");
                return false;
            }
        }
        
        if (request.getType().equals("差旅费")) {
            System.out.println("   差旅费需要检查出差必要性");
            request.setApprovalComment("差旅费用合理，部门经理批准");
            return true;
        }
        
        // 其他类型的申请
        System.out.println("   检查部门预算和申请合理性");
        if (request.getAmount() <= maxAmount * 0.8) { // 80%以内直接批准
            request.setApprovalComment("在部门预算范围内，部门经理批准");
            return true;
        } else {
            request.setApprovalComment("接近预算上限，需要更高级别审批");
            return false;
        }
    }
}

/**
 * 财务总监 - 具体处理者
 */
public class FinanceDirector extends ApprovalHandler {
    
    public FinanceDirector(String name) {
        super("财务总监-" + name, 20000.0);
    }
    
    @Override
    protected boolean doApproval(ApprovalRequest request) {
        System.out.println("🔍 财务总监审批逻辑：");
        
        // 财务总监审批逻辑：重点关注财务合规性
        System.out.println("   检查财务预算和现金流状况");
        
        if (request.getType().equals("投资")) {
            System.out.println("   投资类申请需要详细的ROI分析");
            if (request.getAmount() <= 10000) {
                request.setApprovalComment("投资规模适中，财务总监批准");
                return true;
            } else {
                request.setApprovalComment("投资金额较大，需要董事会审批");
                return false;
            }
        }
        
        // 检查公司整体财务状况（模拟）
        boolean hasEnoughBudget = checkBudgetAvailability(request.getAmount());
        if (hasEnoughBudget) {
            request.setApprovalComment("财务状况良好，财务总监批准");
            return true;
        } else {
            request.setApprovalComment("当前预算紧张，建议延期申请");
            return false;
        }
    }
    
    /**
     * 模拟检查预算可用性
     */
    private boolean checkBudgetAvailability(double amount) {
        // 模拟财务检查逻辑
        System.out.println("   查询当前预算余额...");
        System.out.println("   检查现金流状况...");
        System.out.println("   评估财务风险...");
        
        // 假设90%的概率有足够预算
        return Math.random() > 0.1;
    }
}

/**
 * 总经理 - 具体处理者
 */
public class GeneralManager extends ApprovalHandler {
    
    public GeneralManager(String name) {
        super("总经理-" + name, Double.MAX_VALUE); // 无限权限
    }
    
    @Override
    protected boolean doApproval(ApprovalRequest request) {
        System.out.println("🔍 总经理审批逻辑：");
        
        // 总经理审批逻辑：战略层面考虑
        System.out.println("   从公司战略角度评估申请");
        
        if (request.getAmount() > 50000) {
            System.out.println("   重大支出，需要谨慎考虑");
            
            // 模拟总经理的深度思考
            if (isStrategicallyImportant(request)) {
                request.setApprovalComment("符合公司战略方向，总经理特批");
                return true;
            } else {
                request.setApprovalComment("不符合当前战略重点，总经理不予批准");
                return false;
            }
        } else {
            System.out.println("   常规申请，总经理批准");
            request.setApprovalComment("总经理审批通过");
            return true;
        }
    }
    
    /**
     * 判断是否具有战略重要性
     */
    private boolean isStrategicallyImportant(ApprovalRequest request) {
        System.out.println("   评估战略价值...");
        System.out.println("   考虑长期收益...");
        System.out.println("   分析市场影响...");
        
        // 模拟战略评估（70%概率认为重要）
        return Math.random() > 0.3;
    }
}

4. 责任链建造器和客户端

/**
 * 审批链建造器 - 负责构建责任链
 */
public class ApprovalChainBuilder {
    
    /**
     * 构建标准审批链
     */
    public static ApprovalHandler buildStandardChain() {
        // 创建各级审批者
        DirectSupervisor supervisor = new DirectSupervisor("张主管");
        DepartmentManager manager = new DepartmentManager("李经理");
        FinanceDirector director = new FinanceDirector("王总监");
        GeneralManager gm = new GeneralManager("陈总");
        
        // 构建责任链
        supervisor.setNext(manager)
                 .setNext(director)
                 .setNext(gm);
        
        System.out.println("📋 标准审批链构建完成：");
        printChainInfo(supervisor);
        
        return supervisor; // 返回链的第一个节点
    }
    
    /**
     * 构建快速审批链（跳过部门经理）
     */
    public static ApprovalHandler buildFastTrackChain() {
        DirectSupervisor supervisor = new DirectSupervisor("张主管");
        FinanceDirector director = new FinanceDirector("王总监");
        GeneralManager gm = new GeneralManager("陈总");
        
        // 构建快速通道
        supervisor.setNext(director)
                 .setNext(gm);
        
        System.out.println("📋 快速审批链构建完成：");
        printChainInfo(supervisor);
        
        return supervisor;
    }
    
    /**
     * 打印责任链信息
     */
    private static void printChainInfo(ApprovalHandler firstHandler) {
        ApprovalHandler current = firstHandler;
        int level = 1;
        
        while (current != null) {
            System.out.println("   " + level + ". " + current.getHandlerInfo());
            current = current.nextHandler;
            level++;
        }
    }
}

/**
 * 审批系统 - 客户端
 */
public class ApprovalSystem {
    
    public static void main(String[] args) {
        System.out.println("🎯 === 公司审批系统演示 === 🎯\n");
        
        // 构建审批链
        ApprovalHandler approvalChain = ApprovalChainBuilder.buildStandardChain();
        
        // 创建各种类型的审批请求
        ApprovalRequest[] requests = {
            new ApprovalRequest("REQ001", "张三", "办公用品", 500, 
                              "购买笔记本电脑", "提升工作效率"),
            new ApprovalRequest("REQ002", "李四", "差旅费", 3000, 
                              "出差北京参加培训", "学习新技术"),
            new ApprovalRequest("REQ003", "王五", "设备采购", 15000, 
                              "购买服务器", "扩展业务系统"),
            new ApprovalRequest("REQ004", "赵六", "投资", 80000, 
                              "投资新项目", "开拓新市场"),
            new ApprovalRequest("REQ005", "钱七", "请假", 0, 
                              "病假3天", "身体不适需要休息")
        };
        
        // 处理所有请求
        for (ApprovalRequest request : requests) {
            System.out.println("\n" + "🚀 开始处理审批请求：" + request.getRequestId());
            approvalChain.handleRequest(request);
            
            // 打印最终结果
            printFinalResult(request);
        }
        
        // 演示不同的责任链配置
        demonstrateDifferentChains();
        
        // 性能测试
        performanceTest();
        
        System.out.println("\n🎉 审批系统演示完成！");
    }
    
    /**
     * 打印最终审批结果
     */
    private static void printFinalResult(ApprovalRequest request) {
        System.out.println("\n📊 === 最终审批结果 ===");
        System.out.println("请求ID：" + request.getRequestId());
        System.out.println("申请人：" + request.getApplicant());
        System.out.println("申请类型：" + request.getType());
        System.out.println("申请金额：" + request.getAmount() + " 元");
        System.out.println("审批状态：" + request.getStatus().getDescription());
        System.out.println("审批人：" + (request.getApprover() != null ? request.getApprover() : "无"));
        if (request.getApprovalComment() != null) {
            System.out.println("审批意见：" + request.getApprovalComment());
        }
        
        long processingTime = System.currentTimeMillis() - request.getSubmitTime();
        System.out.println("处理耗时：" + processingTime + " 毫秒");
        System.out.println("========================\n");
    }
    
    /**
     * 演示不同的责任链配置
     */
    private static void demonstrateDifferentChains() {
        System.out.println("\n🔄 === 演示不同责任链配置 === 🔄");
        
        // 快速审批链
        System.out.println("\n--- 使用快速审批链处理紧急申请 ---");
        ApprovalHandler fastChain = ApprovalChainBuilder.buildFastTrackChain();
        
        ApprovalRequest urgentRequest = new ApprovalRequest("URG001", "紧急", "紧急采购", 8000, 
                                                          "紧急购买防护设备", "疫情防控需要");
        fastChain.handleRequest(urgentRequest);
        printFinalResult(urgentRequest);
    }
    
    /**
     * 性能测试
     */
    private static void performanceTest() {
        System.out.println("⚡ === 责任链性能测试 === ⚡");
        
        ApprovalHandler chain = ApprovalChainBuilder.buildStandardChain();
        
        long startTime = System.currentTimeMillis();
        
        // 批量处理1000个请求
        for (int i = 0; i < 1000; i++) {
            ApprovalRequest request = new ApprovalRequest("PERF" + i, "测试用户", "测试", 
                                                        Math.random() * 10000, "性能测试", "测试用");
            chain.handleRequest(request);
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("处理1000个请求耗时：" + (endTime - startTime) + " 毫秒");
        System.out.println("平均每个请求处理时间：" + (endTime - startTime) / 1000.0 + " 毫秒");
    }
}

🚀 责任链模式的扩展应用

1. Spring框架中的责任链模式

Filter过滤器链：

/**
 * Spring Security中的过滤器链就是责任链模式
 */
@Component
public 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 {
            // 认证失败，中断链条
            response.getWriter().write("Authentication Failed");
        }
    }
    
    private boolean isAuthenticated(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        return token != null && validateToken(token);
    }
    
    private boolean validateToken(String token) {
        // 模拟token验证
        return "valid-token".equals(token);
    }
}

// 配置过滤器链
@Configuration
public class SecurityConfig {
    
    @Bean
    public FilterRegistrationBean<AuthenticationFilter> authFilter() {
        FilterRegistrationBean<AuthenticationFilter> registration = 
            new FilterRegistrationBean<>();
        registration.setFilter(new AuthenticationFilter());
        registration.addUrlPatterns("/api/*");
        registration.setOrder(1); // 设置过滤器顺序
        return registration;
    }
}

HandlerInterceptor拦截器链：

/**
 * Spring MVC的拦截器链
 */
@Component
public class LoggingInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        
        System.out.println("📝 请求日志：" + request.getRequestURI());
        
        // 返回true继续处理，false中断链条
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, 
                          HttpServletResponse response, 
                          Object handler, 
                          ModelAndView modelAndView) throws Exception {
        
        System.out.println("✅ 请求处理完成：" + request.getRequestURI());
    }
}

@Component
public class AuthorizationInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        
        // 权限检查
        if (hasPermission(request)) {
            return true; // 继续执行
        } else {
            response.setStatus(403);
            response.getWriter().write("Access Denied");
            return false; // 中断执行
        }
    }
    
    private boolean hasPermission(HttpServletRequest request) {
        // 模拟权限检查
        String userRole = request.getHeader("User-Role");
        return "ADMIN".equals(userRole) || "USER".equals(userRole);
    }
}

2. 异常处理责任链

/**
 * 异常处理责任链
 */
public abstract class ExceptionHandler {
    
    protected ExceptionHandler nextHandler;
    
    public ExceptionHandler setNext(ExceptionHandler nextHandler) {
        this.nextHandler = nextHandler;
        return nextHandler;
    }
    
    public void handleException(Exception exception) {
        if (canHandle(exception)) {
            doHandle(exception);
        } else if (nextHandler != null) {
            nextHandler.handleException(exception);
        } else {
            // 没有处理器能处理，记录错误
            System.err.println("无法处理的异常：" + exception.getClass().getSimpleName());
        }
    }
    
    protected abstract boolean canHandle(Exception exception);
    protected abstract void doHandle(Exception exception);
}

/**
 * 业务异常处理器
 */
class BusinessExceptionHandler extends ExceptionHandler {
    
    @Override
    protected boolean canHandle(Exception exception) {
        return exception instanceof IllegalArgumentException ||
               exception instanceof IllegalStateException;
    }
    
    @Override
    protected void doHandle(Exception exception) {
        System.out.println("🔧 业务异常处理：" + exception.getMessage());
        // 记录业务日志，返回友好提示
    }
}

/**
 * 系统异常处理器
 */
class SystemExceptionHandler extends ExceptionHandler {
    
    @Override
    protected boolean canHandle(Exception exception) {
        return exception instanceof RuntimeException;
    }
    
    @Override
    protected void doHandle(Exception exception) {
        System.err.println("⚠️ 系统异常处理：" + exception.getMessage());
        // 发送告警，记录详细日志
    }
}

/**
 * 默认异常处理器
 */
class DefaultExceptionHandler extends ExceptionHandler {
    
    @Override
    protected boolean canHandle(Exception exception) {
        return true; // 处理所有异常
    }
    
    @Override
    protected void doHandle(Exception exception) {
        System.err.println("💥 未知异常：" + exception.getClass().getSimpleName());
        exception.printStackTrace();
        // 记录完整异常信息，发送紧急告警
    }
}

// 使用示例
public class ExceptionDemo {
    public static void main(String[] args) {
        // 构建异常处理链
        ExceptionHandler chain = new BusinessExceptionHandler()
            .setNext(new SystemExceptionHandler())
            .setNext(new DefaultExceptionHandler());
        
        // 测试不同类型的异常
        chain.handleException(new IllegalArgumentException("参数错误"));
        chain.handleException(new NullPointerException("空指针异常"));
        chain.handleException(new IOException("IO异常"));
    }
}

3. 中间件处理管道

/**
 * HTTP请求处理中间件
 */
public interface Middleware {
    void process(HttpRequest request, HttpResponse response, MiddlewareChain chain);
}

/**
 * 中间件链
 */
public class MiddlewareChain {
    private List<Middleware> middlewares = new ArrayList<>();
    private int currentIndex = 0;
    
    public void addMiddleware(Middleware middleware) {
        middlewares.add(middleware);
    }
    
    public void proceed(HttpRequest request, HttpResponse response) {
        if (currentIndex < middlewares.size()) {
            Middleware current = middlewares.get(currentIndex++);
            current.process(request, response, this);
        }
    }
}

/**
 * 日志中间件
 */
class LoggingMiddleware implements Middleware {
    
    @Override
    public void process(HttpRequest request, HttpResponse response, MiddlewareChain chain) {
        long startTime = System.currentTimeMillis();
        
        System.out.println("📝 请求开始：" + request.getMethod() + " " + request.getUri());
        
        // 继续处理
        chain.proceed(request, response);
        
        long endTime = System.currentTimeMillis();
        System.out.println("📝 请求结束：耗时 " + (endTime - startTime) + "ms");
    }
}

/**
 * 认证中间件
 */
class AuthenticationMiddleware implements Middleware {
    
    @Override
    public void process(HttpRequest request, HttpResponse response, MiddlewareChain chain) {
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            System.out.println("🔐 认证通过");
            chain.proceed(request, response);
        } else {
            System.out.println("❌ 认证失败");
            response.setStatus(401);
            response.setBody("Unauthorized");
        }
    }
}

/**
 * 业务处理中间件
 */
class BusinessMiddleware implements Middleware {
    
    @Override
    public void process(HttpRequest request, HttpResponse response, MiddlewareChain chain) {
        System.out.println("💼 执行业务逻辑");
        
        // 模拟业务处理
        response.setStatus(200);
        response.setBody("Success");
        
        // 业务处理通常是最后一个，不需要调用chain.proceed()
    }
}

// 模拟HTTP请求和响应
class HttpRequest {
    private String method;
    private String uri;
    private Map<String, String> headers = new HashMap<>();
    
    // getters and setters
    public String getMethod() { return method; }
    public void setMethod(String method) { this.method = method; }
    
    public String getUri() { return uri; }
    public void setUri(String uri) { this.uri = uri; }
    
    public String getHeader(String name) { return headers.get(name); }
    public void setHeader(String name, String value) { headers.put(name, value); }
}

class HttpResponse {
    private int status;
    private String body;
    
    // getters and setters
    public int getStatus() { return status; }
    public void setStatus(int status) { this.status = status; }
    
    public String getBody() { return body; }
    public void setBody(String body) { this.body = body; }
}

🎯 面试热点问题

Q1: 责任链模式和装饰者模式有什么区别？

面试官经常问的问题！

记忆技巧：

• 责任链模式：接力赛跑 - 找到能跑的人就停下
• 装饰者模式：流水线 - 每个工位都要处理

Q2: 如何避免责任链过长的问题？

常见解决方案：

1. 设置链长度限制

public class SafeChainHandler extends ApprovalHandler {
    private static final int MAX_CHAIN_LENGTH = 10;
    private int chainLength = 0;
    
    @Override
    public final void handleRequest(ApprovalRequest request) {
        if (chainLength++ > MAX_CHAIN_LENGTH) {
            throw new RuntimeException("责任链过长，可能存在循环引用");
        }
        
        super.handleRequest(request);
    }
}

2. 使用Builder模式优化链构建

public class ChainBuilder {
    private List<ApprovalHandler> handlers = new ArrayList<>();
    
    public ChainBuilder addHandler(ApprovalHandler handler) {
        handlers.add(handler);
        return this;
    }
    
    public ApprovalHandler build() {
        if (handlers.isEmpty()) {
            throw new IllegalStateException("链不能为空");
        }
        
        // 验证链的合理性
        validateChain();
        
        // 构建链
        for (int i = 0; i < handlers.size() - 1; i++) {
            handlers.get(i).setNext(handlers.get(i + 1));
        }
        
        return handlers.get(0);
    }
    
    private void validateChain() {
        // 检查权限递增
        for (int i = 0; i < handlers.size() - 1; i++) {
            if (handlers.get(i).maxAmount >= handlers.get(i + 1).maxAmount) {
                throw new IllegalArgumentException("权限配置错误");
            }
        }
    }
}

Q3: 责任链模式的优缺点？

优点：

• ✅ 降低耦合度：请求者不需要知道具体处理者
• ✅ 动态组合：可以动态改变链的结构
• ✅ 职责单一：每个处理者只关心自己能处理的请求
• ✅ 易于扩展：增加新的处理者不影响其他代码

缺点：

• ❌ 性能问题：请求可能遍历整个链
• ❌ 调试困难：运行时确定处理者，难以跟踪
• ❌ 不保证处理：可能没有处理者能处理请求
• ❌ 链过长问题：处理者过多影响性能

Q4: 何时使用责任链模式？

适用场景：

1. 多个对象可以处理请求：但具体哪个处理者在运行时确定
2. 动态指定处理者：需要在运行时动态指定处理者集合
3. 解耦发送者和接收者：不希望发送者知道具体的接收者
4. 顺序处理：请求需要按特定顺序处理

经典应用：

• 审批工作流系统
• Web框架的过滤器链
• 异常处理机制
• 事件处理系统
• 中间件管道

不适用场景：

• 处理者确定且固定
• 对性能要求极高
• 处理逻辑简单

Q5: 如何设计一个高性能的责任链？

优化策略：

1. 使用索引快速定位

public class IndexedChain {
    private Map<Class<?>, ApprovalHandler> handlerMap = new HashMap<>();
    
    public void addHandler(Class<?> requestType, ApprovalHandler handler) {
        handlerMap.put(requestType, handler);
    }
    
    public void handleRequest(ApprovalRequest request) {
        ApprovalHandler handler = handlerMap.get(request.getClass());
        if (handler != null) {
            handler.handleRequest(request);
        }
    }
}

2. 提前终止优化

public abstract class OptimizedHandler extends ApprovalHandler {
    
    @Override
    public final void handleRequest(ApprovalRequest request) {
        // 快速判断是否可能处理
        if (quickCheck(request)) {
            super.handleRequest(request);
        } else {
            // 直接传递给下一个
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
    
    protected abstract boolean quickCheck(ApprovalRequest request);
}

3. 缓存处理结果

public class CachedChain {
    private Map<String, ApprovalHandler> cache = new ConcurrentHashMap<>();
    
    public void handleRequest(ApprovalRequest request) {
        String key = generateKey(request);
        ApprovalHandler handler = cache.get(key);
        
        if (handler != null) {
            handler.handleRequest(request);
        } else {
            // 遍历链找到处理者，并缓存结果
            handler = findHandler(request);
            if (handler != null) {
                cache.put(key, handler);
                handler.handleRequest(request);
            }
        }
    }
}

💡 总结

责任链模式就像是给你的请求安排了一个"智能分发系统"，让每个请求都能找到最合适的处理者！

记住这个口诀：

请求沿链传递走，找到处理就停留

解耦发送和接收，动态组合真灵活！

实战建议：

1. 明确处理顺序：确保处理者的顺序符合业务逻辑
2. 设置兜底机制：提供默认处理者处理无法识别的请求
3. 优化性能：对于高频调用场景，考虑使用缓存和索引
4. 链长度控制：避免责任链过长影响性能和可维护性

责任链模式不仅仅是一种设计模式，更是一种请求路由的编程思想。当你需要根据请求特征动态选择处理者时，责任链模式就是你的最佳选择！