Java责任链模式

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

模式定义

意图：使多个对象都有机会处理请求，避免请求发送者与接收者耦合。

适用场景

• 多个对象可处理同一请求
• 处理者顺序不确定
• 动态指定处理者

模式结构

抽象处理者

public abstract class Handler {
    protected Handler next;  // 下一个处理者

    public Handler setNext(Handler next) {
        this.next = next;
        return next;  // 返回next便于链式构建
    }

    public abstract void handleRequest(String request);
}

具体处理者

public class HandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("HandlerA处理请求: " + request);
        } else if (next != null) {
            next.handleRequest(request);  // 传递给下一个
        }
    }
}

public class HandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("HandlerB处理请求: " + request);
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}

public class HandlerC extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("C".equals(request)) {
            System.out.println("HandlerC处理请求: " + request);
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("无处理者处理: " + request);
        }
    }
}

链式构建

Handler handlerA = new HandlerA();
Handler handlerB = new HandlerB();
Handler handlerC = new HandlerC();

// 构建责任链：A → B → C
handlerA.setNext(handlerB).setNext(handlerC);

// 发送请求
handlerA.handleRequest("A");  // HandlerA处理
handlerA.handleRequest("B");  // HandlerB处理
handlerA.handleRequest("C");  // HandlerC处理
handlerA.handleRequest("D");  // 无处理者处理

实际应用示例

审批流程

public abstract class Approver {
    protected Approver next;
    protected String name;

    public Approver(String name) {
        this.name = name;
    }

    public Approver setNext(Approver next) {
        this.next = next;
        return next;
    }

    public abstract void approve(int amount);
}

public class Manager extends Approver {
    public Manager(String name) {
        super(name);
    }

    @Override
    public void approve(int amount) {
        if (amount <= 1000) {
            System.out.println(name + "经理审批: " + amount + "元");
        } else if (next != null) {
            next.approve(amount);
        }
    }
}

public class Director extends Approver {
    public Director(String name) {
        super(name);
    }

    @Override
    public void approve(int amount) {
        if (amount <= 5000) {
            System.out.println(name + "总监审批: " + amount + "元");
        } else if (next != null) {
            next.approve(amount);
        }
    }
}

public class CEO extends Approver {
    public CEO(String name) {
        super(name);
    }

    @Override
    public void approve(int amount) {
        System.out.println(name + "CEO审批: " + amount + "元");
    }
}

// 构建：经理 → 总监 → CEO
Approver manager = new Manager("张经理");
Approver director = new Director("李总监");
Approver ceo = new CEO("王CEO");

manager.setNext(director).setNext(ceo);

manager.approve(500);    // 张经理审批
manager.approve(3000);   // 李总监审批
manager.approve(10000);  // 王CEO审批

Servlet过滤器链

public interface Filter {
    void doFilter(String request, FilterChain chain);
}

public class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public void addFilter(Filter filter) {
        filters.add(filter);
    }

    public void doFilter(String request) {
        if (index < filters.size()) {
            Filter filter = filters.get(index++);
            filter.doFilter(request, this);
        } else {
            System.out.println("到达目标资源");
        }
    }
}

// 过滤器实现
public class EncodingFilter implements Filter {
    @Override
    public void doFilter(String request, FilterChain chain) {
        System.out.println("编码处理: " + request);
        chain.doFilter(request);  // 传递给下一个
    }
}

public class AuthFilter implements Filter {
    @Override
    public void doFilter(String request, FilterChain chain) {
        System.out.println("权限检查: " + request);
        chain.doFilter(request);
    }
}

// 使用
FilterChain chain = new FilterChain();
chain.addFilter(new EncodingFilter());
chain.addFilter(new AuthFilter());
chain.doFilter("request");

责任链模式优点

1. 解耦请求发送者与处理者
2. 动态调整处理链
3. 新增处理者容易
4. 分担处理逻辑

适用场景

1. 多级审批
2. 异常处理链
3. 日志处理链
4. 过滤器链
5. 拦截器链

注意事项

避免循环链导致无限循环

请求可能无人处理，需兜底处理者

长链影响性能，应控制长度

Servlet Filter和Spring Interceptor是典型应用

要点总结

1. 责任链将请求沿链传递，直到有处理者处理
2. 处理者持有下一个处理者引用
3. 链式构建灵活组织处理顺序
4. 审批流程、过滤器链是典型应用
5. 需避免无人处理的请求和循环链