扫盲：责任链模式，先有责任后有链

什么是责任链模式？

生活中的责任链

责任链模式在生活中体现比比皆是。

程序员找女朋友很难，好不容易找到一个心仪的对象后准备结婚，却发现还有几个流程才能正式成为合法夫妻。先带上 10 箱茅台飞天把老丈人陪好，老丈人同意了。但有些家庭老丈母才是家庭地位最高的人，所以老丈人决定不了，老丈母在检查一下车房都有，1000 万彩礼也没问题，也同意了。这时候还需要民政局检查一下是否双方都未婚，只有民政局最终确认没问题了，才会请求成功。

程序中的责任链

程序中的责任链也很多，但大多数都比较复杂，我们就模拟一个场景。

现在 PM 提了一个需求，首先是初级工程师接受。如果初级工程师能够实现，直接实现。如果不行，交给中级工程师。如果中级工程师能够实现，直接实现。如果不行，交给高级工程师。如果高级工程师能够实现，直接实现。如果不行，直接跟产品说，需求无法实现。

要，先想想上方场景假设我们用代码实现，可能会是这样的。

class Developer0 {
    public boolean process(int difficulty) {
        return difficulty <= 0;
    }
}

class Developer1 {
    public boolean process(int difficulty) {
        return difficulty <= 1;
    }
}

class Developer2 {
    public boolean process(int difficulty) {
        return difficulty <= 2;
    }
}

public class DemandManager {
    public void processDemand(int difficulty) {
        boolean result0 = new Developer0().process(difficulty);
        if (result0) {
            System.out.println("Developer0：能处理这个需求");
        } else {
            System.out.println("Developer0：不能处理这个需求");
            boolean result1 = new Developer1().process(difficulty);
            if (result1) {
                System.out.println("Developer1：能处理这个需求");
            } else {
                System.out.println("Developer1：不能处理这个需求");
                boolean result2 = new Developer2().process(difficulty);
                if (result2) {
                    System.out.println("Developer2：能处理这个需求");
                } else {
                    System.out.println("Developer2：不能处理这个需求");
                }
            }
        }
    }
}

客户端调用：

DemandManager demandManager = new DemandManager();
demandManager.processDemand(1);

执行打印为：

Developer0：不能处理这个需求
Developer1：不能处理这个需求
Developer2：能处理这个需求

可以很明显看到，虽然我们实现了需求，但是咱们这个实现非常不好，具体不好在哪儿呢？

对于客户端来讲，只关心需求能否处理，而不关心到底由谁完成。假设我们又增加了工程师，那就意味着 DemandManager 也需要更改，这很明显违背了开闭原则。

如果我们能让各个开发者之间形成一定的关联，能逐级传递用户的请求，直到解决这个请求为止，这样就解决了我们上面的痛点了。

没错，责任链模式就是专为解决这一问题而生的。

责任链模式

责任链模式的定义

使 多个对象 都有机会 处理请求，从而避免请求的发送者和接收者的耦合关系。将多个对象 形成一条链，并沿着这条链 传递 该请求，直到有一个对象处理它为止。

责任链模式的结构图

从定义上来看，发出请求的客户端并不知道这个链上的哪一个对象最终处理这个请求，这样系统的更改可以在不影响客户端的情况下重新组织和分配责任。

听起来还不错，那怎么做呢？

角色	类别	说明
Handler	抽象处理者	抽象类或者接口,定义处理请求的方法以及持有下一个 Handler 的引用
ConcreteHandler1 ConcreteHandler2	具体处理者	实现抽象处理类，对请求进行处理，如果不处理则转发给下一个处理者
Client	客户端	要使用责任链模式的地方

责任链模式实现

上面说责任链模式能处理这个问题，那我们根据结构图来临摹一番吧。

1. 定义处理者抽象类

public abstract class Developer {

    protected Developer nextDeveloper;

    public void setNextDeveloper(Developer developer) {
        this.nextDeveloper = developer;
    }

    public abstract boolean process(int difficulty);
}

2. 定义实现类

class Developer0 extends Developer {
    @Override
    public boolean process(int difficulty) {
        if (difficulty <= 0) {
            System.out.println("Developer0:我能处理这个需求");
            return true;
        } else if (nextDeveloper != null) {
            System.out.println("Developer0:我不能处理这个需求，交由他人");
            return nextDeveloper.process(difficulty);
        } else {
            System.out.println("Developer0:这个需求无法实现！");
            return false;
        }
    }
}

class Developer1 extends Developer {
    @Override
    public boolean process(int difficulty) {
        if (difficulty <= 1) {
            System.out.println("Developer1:我能处理这个需求");
            return true;
        } else if (nextDeveloper != null) {
            System.out.println("Developer1:我不能处理这个需求，交由他人");
            return nextDeveloper.process(difficulty);
        } else {
            System.out.println("Developer1:这个需求无法实现！");
            return false;
        }
    }
}

class Developer2 extends Developer {
    @Override
    public boolean process(int difficulty) {
        if (difficulty <= 2) {
            System.out.println("Developer2:我能处理这个需求");
            return true;
        } else if (nextDeveloper != null) {
            System.out.println("Developer2:我不能处理这个需求，交由他人");
            return nextDeveloper.process(difficulty);
        } else {
            System.out.println("Developer2:这个需求无法实现！");
            return false;
        }
    }
}

3. 客户端测试

// 构造开发者集合类，可任意添加
Developer0 developer0 = new Developer0();
Developer1 developer1 = new Developer1();
Developer2 developer2 = new Developer2();
developer1.setNextDeveloper(developer2);
developer0.setNextDeveloper(developer1);

// 分别交给初级工程师难度为 0 1 2 3 的需求
System.out.println("需求难度0");
developer0.process(0);
System.out.println();
System.out.println("需求难度1");
developer0.process(1);
System.out.println();
System.out.println("需求难度2");
developer0.process(2);
System.out.println();
System.out.println("需求难度3");
developer0.process(3);

4. 打印结果

需求难度0
Developer0:我能处理这个需求

需求难度1
Developer0:我不能处理这个需求，交由他人
Developer1:我能处理这个需求

需求难度2
Developer0:我不能处理这个需求，交由他人
Developer1:我不能处理这个需求，交由他人
Developer2:我能处理这个需求

需求难度3
Developer0:我不能处理这个需求，交由他人
Developer1:我不能处理这个需求，交由他人
Developer2:这个需求无法实现！

责任链模式的优点

1. 接收者和发送者都没有对方的信息，完全解耦，提高了代码灵活性；
2. 只需要一个指向后继者的引用，可以灵活插入链处理；

责任链模式的缺点

1. 责任链过长的话，或者链上的结点判断处理时间太长的话会影响性能，特别是递归循环的时候。
2. 请求有可能遍历完链都得不到处理。
3. Debug 麻烦，每一级都需要跟进去看；

责任链模式的适用场景

相信从上面的例子大家也能知晓责任链模式的适用场景了。

责任链模式非常适合在满足以下条件的场景中：

1. 多个对象都可以处理同一请求，但具体由哪个请求处理需要运行时判断；
2. 具体处理者不明确的情况下，向一组处理者对象提交了一个请求，客户端不关心谁处理请求。

源码中的责任链模式

• Android 的事件分发机制和责任链模式非常类似；
• OkHttp 的请求处理拦截器；

写在最后

总的来说，责任链模式也是一个项目开发中会使用非常频繁的模式，你学会了么？如有疑问，请在评论区留言。