行为模式之责任链模式

1 责任链模式介绍

为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

责任链模式的核⼼是解决⼀组服务中的先后执⾏处理关系，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。

职责链模式主要包含以下角色。

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

责任链模式的独到之处是将其节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。

2 简单入门程序

简单模拟工作中的流程审批：

public interface Handler {


    Handler next();

    void setNext(Handler handler);

    void doHandle(Order order);

}

public abstract class AbstractHandler implements Handler {

    private Handler nextHandler;


    @Override
    public Handler next() {
        return this.nextHandler;
    }

    @Override
    public void setNext(Handler handler) {
        this.nextHandler = handler;
    }

    @Override
    public void doHandle(Order order) {
        this.handleOrder(order);
        if (this.nextHandler != null) {
            this.nextHandler.doHandle(order);
        }
    }

    abstract void handleOrder(Order order);
    
}

public class Grouper extends AbstractHandler {
    @Override
    void handleOrder(Order order) {
        System.out.println("小组长审批工单完成");
    }
}

public class Manager extends AbstractHandler {
    @Override
    void handleOrder(Order order) {
        // 模拟经理审批工单逻辑。。。
        System.out.println("经理审批工单完成");
    }
}

测试：

    public static void main(String[] args) {
        AbstractHandler grouper = new Grouper();
        AbstractHandler manager = new Manager();
        grouper.setNext(manager);

        Order order = new Order();
        grouper.doHandle(order);
    }

3 模拟实现web的filter

 public interface Filter {
 	public 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 前置处理");

        // 先执行所有request再倒序执行所有response
        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 前置处理");

        // 先执行所有request再倒序执行所有response
        chain.doFilter(request, response);

        System.out.println("过滤器2 后置处理");
    }
}

模拟实现过滤器连

public class FilterChain {

    private List<Filter> filters = new ArrayList<Filter>();

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