本文共 4509 字，大约阅读时间需要 15 分钟。

责任链模式（Chain of Responsibility Pattern）

概述

在现实生活中，某些请求需要多个对象来处理，而每个对象的处理条件和权限却各不相同。例如，员工请假需要不同级别的领导审批，且每个领导能审批的天数范围不同。这种情况可以通过责任链模式来解决。

定义

责任链模式通过将所有请求的处理者连接成一条链，使得请求沿着这条链传递，直到有对象能够处理它为止。这种方式避免了请求发送者与多个处理者耦合的问题，从而降低了系统的耦合度。

结构角色

案例实现

请假流程控制系统

• 请假天数范围：
  • 1天以下：小组长审批
  • 1-3天：部门经理审批
  • 3-7天：总经理审批

类图

GroupLeader → Manager → GeneralManager

代码示例

public class LeaveRequest {
    private String name;
    private int num;
    private String content;
    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }
    public String getName() { return name; }
    public int getNum() { return num; }
    public String getContent() { return content; }
}

public abstract class Handler {
    protected static final int NUM_ONE = 1;
    protected static final int NUM_THREE = 3;
    protected static final int NUM_SEVEN = 7;
    private int numStart;
    private int numEnd;
    private Handler nextHandler;
    public Handler(int numStart) { this.numStart = numStart; }
    public Handler(int numStart, int numEnd) { this.numStart = numStart; this.numEnd = numEnd; }
    public void setNextHandler(Handler nextHandler) { this.nextHandler = nextHandler; }
    public final void submit(LeaveRequest leave) {
        if (0 == numStart) return;
        if (leave.getNum() >= numStart) {
            handleLeave(leave);
            if (nextHandler != null && leave.getNum() > numEnd) {
                nextHandler.submit(leave);
            } else {
                System.out.println("流程结束");
            }
        }
    }
    protected abstract void handleLeave(LeaveRequest leave);
}
// 具体处理者类
public class GroupLeader extends Handler {
    public GroupLeader() { super(0, Handler.NUM_ONE); }
    @Override protected void handleLeave(LeaveRequest leave) {
        System.out.println("小组长审批：同意");
    }
}
public class Manager extends Handler {
    public Manager() { super(Handler.NUM_ONE, Handler.NUM_THREE); }
    @Override protected void handleLeave(LeaveRequest leave) {
        System.out.println("部门经理审批：同意");
    }
}
public class GeneralManager extends Handler {
    public GeneralManager() { super(Handler.NUM_THREE, Handler.NUM_SEVEN); }
    @override protected void handleLeave(LeaveRequest leave) {
        System.out.println("总经理审批：同意");
    }
}
public class Client {
    public static void main(String[] args) {
        LeaveRequest leave = new LeaveRequest("张三", 5, "身体不适");
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();
        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);
        groupLeader.submit(leave);
    }
}

输出

张三请假5天，身体不适。小组长审批：同意。部门经理审批：同意。总经理审批：同意流程结束！

优缺点

优点

• 降低耦合度：请求发送者与处理者无耦合。
• 增强可扩展性：支持动态添加处理者。
• 灵活职责分配：允许动态调整链成员和职责范围。
• 责任分担：每个处理者专注于自己职责。

缺点

• 无法保证处理：请求可能传递至链末端未被处理。
• 性能影响：长链处理可能影响系统性能。
• 客户端复杂性：需确保链正确配置，避免循环调用。

JavaWeb应用中的FilterChain

public interface Filter {
    void doFilter(Request req, Response res, FilterChain c);
}
public class FirstFilter implements Filter {
    @Override public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("过滤器1 前置处理");
        chain.doFilter(request, response);
        System.out.println("过滤器1 后置处理");
    }
}
public class SecondFilter implements Filter {
    @override public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("过滤器2 前置处理");
        chain.doFilter(request, response);
        System.out.println("过滤器2 后置处理");
    }
}
public class FilterChain {
    private List
   
     filters = new ArrayList<>();
    private int index = 0;
    public FilterChain addFilter(Filter filter) { this.filters.add(filter); return this; }
    public void doFilter(Request request, Response response) {
        if (index == filters.size()) return;
        Filter filter = filters.get(index);
        index++;
        filter.doFilter(request, response, this);
    }
}
public class Client {
    public static void main(String[] args) {
        Request req = null;
        Response res = null;
        FilterChain filterChain = new FilterChain();
        filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
        filterChain.doFilter(req, res);
    }
}
   

输出

过滤器1 前置处理过滤器2 前置处理过滤器2 后置处理过滤器1 后置处理

转载地址：http://mzhfk.baihongyu.com/