行为型-责任链模式

概述

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

适用场景

• 有多个对象可以处理同一个请求
• 在不明确指定接收者的情况下，向多个对象中的一个提交请求
• 可动态指定一组对象处理请求

角色组成

• Handler（抽象处理者）：定义处理请求的接口
• ConcreteHandler（具体处理者）：处理请求或将请求传递给下一个处理者
• Client（客户端）：创建处理链，向链头提交请求

代码实现

1. 请求类

public 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; }
}

2. 抽象处理者

public abstract class Handler {
    protected Handler nextHandler;
    
    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }
    
    public abstract void handleRequest(LeaveRequest request);
}

3. 具体处理者

// 组长（3天以内）
public class TeamLeader extends Handler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("组长批准 " + request.getName() + " 请假 " + request.getDays() + " 天");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 经理（7天以内）
public class Manager extends Handler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 7) {
            System.out.println("经理批准 " + request.getName() + " 请假 " + request.getDays() + " 天");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 总监（15天以内）
public class Director extends Handler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 15) {
            System.out.println("总监批准 " + request.getName() + " 请假 " + request.getDays() + " 天");
        } else {
            System.out.println(request.getName() + " 请假 " + request.getDays() + " 天，天数过多，不予批准");
        }
    }
}

4. 客户端

public class Client {
    public static void main(String[] args) {
        // 构建责任链
        Handler teamLeader = new TeamLeader();
        Handler manager = new Manager();
        Handler director = new Director();
        
        teamLeader.setNextHandler(manager);
        manager.setNextHandler(director);
        
        // 提交请求
        teamLeader.handleRequest(new LeaveRequest("张三", 2));
        teamLeader.handleRequest(new LeaveRequest("李四", 5));
        teamLeader.handleRequest(new LeaveRequest("王五", 10));
        teamLeader.handleRequest(new LeaveRequest("赵六", 20));
    }
}

# 输出
组长批准 张三 请假 2 天
经理批准 李四 请假 5 天
总监批准 王五 请假 10 天
赵六 请假 20 天，天数过多，不予批准

类图

Servlet Filter 中的责任链

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

// FilterChain 管理责任链
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        System.out.println("Filter 前置处理");
        chain.doFilter(request, response);  // 传递给下一个
        System.out.println("Filter 后置处理");
    }
}

优缺点

优点：

• 降低耦合度
• 增强给对象指派职责的灵活性
• 增加新的请求处理类很方便

缺点：

• 不能保证请求一定被接收
• 系统性能可能受到影响
• 调试不方便