Java行为型模式---责任链模式-优快云博客

本文链接：https://blog.youkuaiyun.com/hqxstudying/article/details/149367250

责任链模式基础概念

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，其核心思想是将请求的发送者和接收者解耦，使多个对象都有机会处理请求。这些对象连接成一条链，请求沿着链传递，直到有一个对象处理它为止。责任链模式允许动态地组合处理者，增加系统的灵活性和可扩展性。

责任链模式的核心组件

抽象处理者（Handler） - 定义处理请求的接口，通常包含一个指向下一个处理者的引用和处理请求的抽象方法。
具体处理者（ConcreteHandler） - 实现抽象处理者接口，处理请求或转发给下一个处理者。
客户端（Client） - 创建处理者链并向链头提交请求，无需关心请求的具体处理过程。

责任链模式的实现

下面通过一个请假审批的例子展示责任链模式的实现：

// 1. 抽象处理者
abstract class Approver {
    protected Approver successor;  // 指向下一个处理者
    
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }
    
    // 处理请求的抽象方法
    public abstract void processRequest(LeaveRequest request);
}

// 2. 具体处理者 - 项目经理
class ProjectManager extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("项目经理批准了" + request.getName() + "的" + request.getDays() + "天请假申请");
        } else if (successor != null) {
            successor.processRequest(request);  // 转发请求
        }
    }
}

// 3. 具体处理者 - 部门经理
class DepartmentManager extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() <= 7) {
            System.out.println("部门经理批准了" + request.getName() + "的" + request.getDays() + "天请假申请");
        } else if (successor != null) {
            successor.processRequest(request);  // 转发请求
        }
    }
}

// 4. 具体处理者 - CEO
class CEO extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() > 7) {
            System.out.println("CEO批准了" + request.getName() + "的" + request.getDays() + "天请假申请");
        } else if (successor != null) {
            successor.processRequest(request);  // 转发请求
        }
    }
}

// 5. 请求类
class LeaveRequest {
    private String name;  // 请假人姓名
    private int days;     // 请假天数
    
    public LeaveRequest(String name, int days) {
        this.name = name;
        this.days = days;
    }
    
    public String getName() {
        return name;
    }
    
    public int getDays() {
        return days;
    }
}

// 6. 客户端代码
public class ChainOfResponsibilityPatternClient {
    public static void main(String[] args) {
        // 创建处理者
        Approver projectManager = new ProjectManager();
        Approver departmentManager = new DepartmentManager();
        Approver ceo = new CEO();
        
        // 组装责任链
        projectManager.setSuccessor(departmentManager);
        departmentManager.setSuccessor(ceo);
        
        // 提交请求
        LeaveRequest request1 = new LeaveRequest("张三", 2);
        LeaveRequest request2 = new LeaveRequest("李四", 5);
        LeaveRequest request3 = new LeaveRequest("王五", 10);
        
        projectManager.processRequest(request1);
        projectManager.processRequest(request2);
        projectManager.processRequest(request3);
    }
}

责任链模式的变体

纯责任链 - 每个处理者要么处理请求，要么完全不处理（转发给下一个），请求必须被某个处理者处理。
不纯责任链 - 处理者可以部分处理请求后继续转发，请求可能被多个处理者处理。

例如，Servlet Filter 是不纯责任链的典型应用：

public interface Filter {
    void doFilter(ServletRequest request, ServletResponse response, FilterChain chain);
}

public interface FilterChain {
    void doFilter(ServletRequest request, ServletResponse response);
}

// 具体Filter实现
public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        // 前置处理（如身份验证）
        chain.doFilter(request, response);  // 转发给下一个Filter
        // 后置处理（如日志记录）
    }
}