责任链模式--一级一级觅佳音，总有一款适合你（行为模式01）

什么是责任链模式
使多个对象都有机会处理请求。
这个行为模式的关键就是在链的使用，寓意就是对象的链式调用，我解决不了的问题交给下一个对象处理，一级一级的调用，直到找到能解决的对象为止。

责任链模式的适用场景
多对象处理同一请求，但具体处理的对象动态决定。
请求处理对象不明确，轮询处理。

责任链模式中的角色

• Handler：抽象处理角色–抽象声明处理方法，并引用下一节点
• ConcreateHandler：具体处理的角色–Handler的具体实现

责任链模式用例
我们在学校平时最常用到的事例就是请假了，这次我们玩个大的，要请年假（其实是休学），然后我们先给室友说一下，让其做好思想准备，这里相当于第一级，室友处理不了，让你去问班长；班长了解情况和缘由后，向辅导员口头沟通下，所以事情转手到了辅导员这里，辅导员了解具体情况后，发现自己也处理不了这个事情，所以转而向院领导审批，院领导审批通过后，审批证明下发到你手上这个事情解决掉了，请年假成功了。

室友可以帮你处理平常（等级1）的事情：比如买学习资料钱不够向室友借点
班长可以帮你处理班级（等级2）的事情：比如你想以班级为单位组织个比赛队伍
辅导员可以帮你处理（等级3）的事情：比如你有急事要请一天假
院领导可以处理你（等级4）更大一点的事：比如休学、转学等

UML类图

抽象类AbstractHandler:

public abstract class AbstractHandler {
    //高一级处理者
    protected AbstractHandler nextHandler;

    //获取当前级别的处理级别
    public abstract int limit();

    //具体处理方法
    public abstract void handle(int level);

    //判断需求是否满足，否则传递给高一级处理
    public final void handleRequest(int level){
        if(level <= limit()){
            handle(level);
        }else{
            if(null != nextHandler){
                nextHandler.handleRequest(level);
            }
        }
    }
}

室友Roommates：

public class Roommates extends AbstractHandler {

    @Override
    public int limit() {
        // 室友能处理一级级别的事务
        return 1;
    }

    @Override
    public void handle(int level) {
        System.out.println("我是室友，我处理了"+level+"级别的事务！");

    }

}

班长Monitor：

public class Monitor extends AbstractHandler {

    @Override
    public int limit() {
        // 班长能处理的事务等级
        return 2;
    }

    @Override
    public void handle(int level) {
        System.out.println("我是班长，我处理了"+level+"等级的事务！");
    }

}

辅导员Counselor：

public class Counselor extends AbstractHandler {

    @Override
    public int limit() {
        // 辅导员处理的事务级别
        return 3;
    }

    @Override
    public void handle(int level) {
        System.out.println("我是辅导员，我处理了"+level+"级别的事务！");
    }

}

院长Dean：

public class Dean extends AbstractHandler {

    @Override
    public int limit() {
        // 院长处理事务的级别
        return 4;
    }

    @Override
    public void handle(int level) {
        System.out.println("我是院长，我处理了"+level+"级别的事务！");
    }

}

主类调用：

public class Test {

    public static void main(String[] args) {
        //构造初始化各个级别的对象
        Roommates roommates = new Roommates();
        Monitor monitor = new Monitor();
        Counselor counselor = new Counselor();
        Dean dean = new Dean();

        //设置高级别的处理连接点
        roommates.nextHandler = monitor;
        monitor.nextHandler = counselor;
        counselor.nextHandler = dean;

        //我要请假，级别为3
        roommates.handleRequest(3);
    }

}

结果：

我是辅导员，我处理了3级别的事务！

---

说明：
当然也可以另外设置个类记录调用顺序，把下边需要的链都写到这个类里边，调用的时候只调用这个类一次就实现所有的级别初始化，但是结果是一样的，调用的都是从低级到高级实例化，不可能没有一点耦合。

责任链模式总结
没有最好，只有更好。当你设计代码架构，很多模式都可以实现目的，选择哪一个都没有对错，只有最大程度的方便自己。
优点：解耦了调用和实现。
缺点：要遍历才能实现目的，如果处理角色链冗长，那么对于性能来说这个模式不是个好选择。