责任链模式（Chain Of Responsibility）

定义

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

本质

分离职责，动态组合。

登场角色

• Handler（处理者）

  定义了处理请求的接口，处理者角色知道下一个处理者是谁，如果自己无法处理该请求，他会将请求传递给下一个处理者。

• ConcreteHandler（具体的处理者）

  处理请求的具体角色。

• Client（请求者）

  向第一个处理者发送请求的角色。

示例代码

/**
 * 抽象的处理者
 */
public abstract class Leader {
    protected Leader nextLeader;

    /**
     * 自身能报销的额度权限
     * @return
     */
    public abstract int limit();

    /**
     * 处理报销行为
     * @param money
     */
    public abstract void handler(int money);

    /**
     * 处理报账请求
     * @param money
     */
    public final void handlerRequest(int money){
        if(money < limit()){ //如果自己能够处理，就处理
            handler(money);
        }else{
            //如果处理不了，传递给下一个处理者
            if(null != nextLeader){
                nextLeader.handlerRequest(money);
            }
        }
    }
}

/**
 * 处理者
 */
public class GroupLeader extends Leader{
    @Override
    public int limit() {
        return 1000;
    }
    @Override
    public void handler(int money) {
        System.out.println("组长批复报销" + money + "元");
    }
}

/**
 *
 */
public class Director extends Leader{
    @Override
    public int limit() {
        return 5000;
    }

    @Override
    public void handler(int money) {
        System.out.println("主管批复报销" + money + "元");
    }
}



public class Manager extends Leader{
    @Override
    public int limit() {
        return 10000;
    }

    @Override
    public void handler(int money) {
        System.out.println("经理批复报销" + money + "元");
    }
}


public class Boss extends Leader{
    @Override
    public int limit() {
        return Integer.MAX_VALUE;
    }

    @Override
    public void handler(int money) {
        System.out.println("老板批复报销" + money + "元");
    }
}


public class Main {
    public static void main(String[] args){
        GroupLeader groupLeader = new GroupLeader();
        Director director = new Director();
        Manager manager = new Manager();
        Boss boss = new Boss();

        //设置上一级领导者对象
        groupLeader.nextLeader = director;
        director.nextLeader = manager;
        manager.nextLeader = boss;
        //发起报账请求
        groupLeader.handlerRequest(50000);
    }
}

运行结果

老板批复报销50000元

功能

责任链模式主要用来处理”客户端发出一个请求，有多个对象都有机会来处理这一个请求，但是客户端不知道究竟谁会来处理他的请求“这样的情况。也就是需要让请求者和接收者解耦，这样就可以动态的切换和组合接收者了。

优点

• 请求者和接收者松散耦合。
• 动态组合职责。把功能护理分散到单独的职责对象总，然后在使用的时候，可以动态的组合职责形成职责链，从而可以灵活的给对象分噢诶职责，也可以灵活的实现或者改变对象的职责。

缺点

• 产生很多细粒度的对象。
• 不一定能被处理。

何时使用

• 多个对象可以处理同一个请求，但那个对象处理则在运行时动态处理。
• 在请求处理者不明确的情况下，向多个对象中的一个提交一个请求。
• 需要动态指定一组对象处理请求。