设计模式系列：搞懂责任链模式，学会分担职责，学会“踢皮球”

责任链模式的定义：将所有的请求处理者都看成对象，通过前一对象维护下一个对象的引用形成一条链，当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。属于行为型模式。

责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理；责任链模式的独到之处是将其节点处理者组合成为链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。

责任链模式的结构：责任链模式主要包含以下2个角色。

1. 抽象处理者（Handler）：定义一个处理请求的接口，包含抽象处理方法和下一个处理节点对象的引用。
2. 具体处理者（Concrete Handler）：实现抽象处理者的处理方法，判断请求是处理还是转发给下一个处理者。

责任链模式的通用实现：

//抽象处理者
public abstract class Handler {
    protected Handler next;

    public void next(Handler handler){
        this.next = handler;
    }

    abstract void handleRequest(String request);
}

//具体处理者A
public class ConcreteHandlerA extends Handler{
    @Override
    void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("具体处理者A处理该请求！");
        } else {
            next.handleRequest(request);
        }
    }
}

//具体处理者B
public class ConcreteHandlerB extends Handler{
    @Override
    void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("具体处理者A处理该请求！");
        } else {
            System.out.println("请求未处理！");
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        handlerA.next(handlerB);

        handlerA.handleRequest("A");
    }
}

责任链模式的结构图：

责任链模式的应用实例：我们用责任链模式来模拟员工请假流程。假设请假小于等于3天，项目经理可以直接批准；大于3天小于等于10天，部门经理可以批准；大于10天需要公司CEO批准。

在上面的通用实现代码中，链式结构的组装是有客户端组装完成的，当处理链路过长时，链式结构的组装就会变得很复杂，对于复杂结构的创建，我们可以考虑使用建造者模式来复杂组装链式结构，因此下面的代码中用到了责任链模式和建造者模式，使用建造者模式组装链式结构，简化客户端调用。

//抽象领导接口
public abstract class LeaderHandler {
    protected LeaderHandler chain;

    public void next(LeaderHandler leaderHandler){
        this.chain = leaderHandler;
    }

    abstract void approve(int leaveDays);
}

//项目经理审批
public class ProjectManagerHandler extends LeaderHandler{
    @Override
    void approve(int leaveDays) {
        if (leaveDays <= 3) {
            System.out.println("项目经理批准请假" + leaveDays + "天。");
        } else {
            chain.approve(leaveDays);
        }
    }
}

//部门经理审批
public class DeptManagerHandler extends LeaderHandler{
    @Override
    void approve(int leaveDays) {
        if (leaveDays > 3 && leaveDays<= 10) {
            System.out.println("部门经理批准请假" + leaveDays + "天。");
        } else {
            chain.approve(leaveDays);
        }
    }
}

//CEO审批
public class CEOHandler extends LeaderHandler{
    @Override
    void approve(int leaveDays) {
            System.out.println("CEO批准请假" + leaveDays + "天。");
    }
}

//责任链建造者
public class Builder {
    private LeaderHandler head;
    private LeaderHandler tail;

    public Builder addHandler(LeaderHandler leaderHandler){
        if(this.head == null){
            this.head = leaderHandler;
            this.tail = leaderHandler;
            return this;
        }
        this.tail.next(leaderHandler);
        this.tail = leaderHandler;
        return this;
    }

    public LeaderHandler build(){
        return this.head;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.addHandler(new ProjectManagerHandler())
                .addHandler(new DeptManagerHandler())
                .addHandler(new CEOHandler());
        
        builder.build().approve(5);
    }
}

上面实例的结构图：

责任链模式的优点：

1. 请求和处理解耦，降低了对象间的耦合度。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了链路的灵活性，当流程发生变化时，可以动态改变链路结构，也可动态地新增或者删除责任。
4. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

责任链模式的缺点：

1. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到影响。
2. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，职责链设置错误可能导致系统错误，如节点对象的循环引用会造成死循环。

责任链模式的应用场景：

1. 多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定。
2. 可动态指定一组对象处理请求，或添加新的处理者。
3. 需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。

责任链模式在源码中的应用：Spring中的拦截器Filter就采用了责任链模式，可以设置多个拦截器拦截请求。Netty框架中的串行化处理Pipeliine使用了双向链表的数据结构实现的责任链。