责任链模式 (Chain of Responsibility)

📖 通俗理解

公司请假审批：

• 请假 1 天：组长审批
• 请假 3 天：经理审批
• 请假 7 天：总监审批
• 请假超过 7 天：CEO 审批

你只需要提交请假申请，系统会自动找到合适的人审批。

责任链模式就是：将请求沿着处理者链传递，直到有一个处理者能处理它。

🎯 解决什么问题？

问题：一个请求可能被多个对象处理，但具体由谁处理在运行时才确定。

没有责任链的写法：

if (days <= 1) {
    leader.approve();
} else if (days <= 3) {
    manager.approve();
} else if (days <= 7) {
    director.approve();
} else {
    ceo.approve();
}

问题：if-else 太多，难以扩展。

🌰 生活中的例子

• 公司审批流程：员工 → 组长 → 经理 → 总监
• 客服转接：AI → 初级客服 → 高级客服 → 经理
• 过滤器链：登录验证 → 权限验证 → 日志记录

💻 Java 代码实现

场景：请假审批系统

/**
 * 请假请求
 */
public class LeaveRequest {
    private String name;
    private int days;
    private String reason;
    
    public LeaveRequest(String name, int days, String reason) {
        this.name = name;
        this.days = days;
        this.reason = reason;
    }
    // getter...
}

/**
 * 抽象处理者
 */
public abstract class Approver {
    protected Approver nextApprover;
    protected String name;
    
    public Approver(String name) {
        this.name = name;
    }
    
    public void setNext(Approver next) {
        this.nextApprover = next;
    }
    
    public abstract void approve(LeaveRequest request);
}

/**
 * 组长
 */
public class Leader extends Approver {
    
    public Leader(String name) {
        super(name);
    }
    
    @Override
    public void approve(LeaveRequest request) {
        if (request.getDays() <= 1) {
            System.out.println("组长[" + name + "]审批通过：" + 
                request.getName() + "请假" + request.getDays() + "天");
        } else if (nextApprover != null) {
            nextApprover.approve(request);
        }
    }
}

/**
 * 经理
 */
public class Manager extends Approver {
    
    public Manager(String name) {
        super(name);
    }
    
    @Override
    public void approve(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("经理[" + name + "]审批通过：" + 
                request.getName() + "请假" + request.getDays() + "天");
        } else if (nextApprover != null) {
            nextApprover.approve(request);
        }
    }
}

/**
 * 总监
 */
public class Director extends Approver {
    
    public Director(String name) {
        super(name);
    }
    
    @Override
    public void approve(LeaveRequest request) {
        if (request.getDays() <= 7) {
            System.out.println("总监[" + name + "]审批通过：" + 
                request.getName() + "请假" + request.getDays() + "天");
        } else if (nextApprover != null) {
            nextApprover.approve(request);
        }
    }
}

/**
 * CEO
 */
public class CEO extends Approver {
    
    public CEO(String name) {
        super(name);
    }
    
    @Override
    public void approve(LeaveRequest request) {
        System.out.println("CEO[" + name + "]审批通过：" + 
            request.getName() + "请假" + request.getDays() + "天，好好休息！");
    }
}

使用：

public class Client {
    public static void main(String[] args) {
        // 构建责任链
        Approver leader = new Leader("张组长");
        Approver manager = new Manager("李经理");
        Approver director = new Director("王总监");
        Approver ceo = new CEO("老板");
        
        leader.setNext(manager);
        manager.setNext(director);
        director.setNext(ceo);
        
        // 发起请假请求
        leader.approve(new LeaveRequest("小明", 1, "感冒"));
        leader.approve(new LeaveRequest("小红", 3, "旅游"));
        leader.approve(new LeaveRequest("小李", 7, "探亲"));
        leader.approve(new LeaveRequest("小王", 15, "结婚"));
    }
}

输出：

组长[张组长]审批通过：小明请假1天
经理[李经理]审批通过：小红请假3天
总监[王总监]审批通过：小李请假7天
CEO[老板]审批通过：小王请假15天，好好休息！

🔥 实战案例：过滤器链

public interface Filter {
    void doFilter(Request request, Response response, FilterChain chain);
}

public class AuthFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("认证过滤器：检查登录状态...");
        if (request.isAuthenticated()) {
            chain.doFilter(request, response);
        } else {
            response.setError("未登录");
        }
    }
}

public class LogFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("日志过滤器：记录请求...");
        chain.doFilter(request, response);
        System.out.println("日志过滤器：记录响应...");
    }
}

✅ 适用场景

1. 多个对象可以处理请求，具体哪个处理运行时决定
2. 动态组装处理链
3. 不想让调用者知道具体处理者

---

小结

责任链模式：将请求沿着链传递，直到有人处理。

应用：Servlet Filter、Spring Interceptor、Netty Pipeline

👉 下一篇：命令模式