职责链模式

定义：

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

什么是链

1、链是一系列节点的集合。
2、链的各节点可灵活拆分再重组。

角色：

抽象处理者角色(Handler)：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。
具体处理者角色(ConcreteHandler)：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

模板代码：

定义一个处理器对象-Handler

public abstract class Handler {
    
    protected Handler handler;

    /**
     * 处理请求
     * @param condition
     */
    public abstract void handleRequest(String condition);
    
}

定义一个具体的处理者-ConcreteHandler1

public class ConcreteHandler1 extends Handler {

    @Override
    public void handleRequest(String condition) {
        if("条件1".equals(condition)){
            System.out.println("ConcreteHandler1 处理完毕");
        }else{
            System.out.println("ConcreteHandler1 holder不住，交给下一位兄弟...");
            if(handler != null){
                handler.handleRequest(condition);
            }
        }
    }

}

定义具体处理者-ConcreteHandler2

public class ConcreteHandler2 extends Handler {

    @Override
    public void handleRequest(String condition) {
        if("条件2".equals(condition)){
            System.out.println("ConcreteHandler2 处理完毕");
        }else{
            System.out.println("ConcreteHandler2 holder不住，交给下一位兄弟...");
            if(handler != null){
                handler.handleRequest(condition);
            }
        }
    }

}

客户端代码：

public class Client {

    public static void main(String[] args) {
        //处理对象
        Handler h1 = new ConcreteHandler1();
        
        Handler h2 = new ConcreteHandler2();
        
        h1.handler = h2;
        
        h1.handleRequest("条件2");
    }

}

公司审批的案例：

首先有个抽象的领导来报销审批

public abstract class Leader {

    //上一级领导，当自己没有权限审批时，交给上一级领导
    protected Leader nextHandler;
    
    public final void handleRequest(int money){
        //在权限范围内
        if(money <= limit()){
            handle(money);
        }else{
            //超过能够审批的最大金额，交给上一级领导
            nextHandler.handleRequest(money);
        }
    }
    
    /**
     * 能审批的最大金额
     * @return
     */
    public abstract int limit();
    
    /**
     * 处理报账
     * @param money
     */
    public abstract void handle(int money);
}

组长审批范围:

public class GroupLeader extends Leader{

    @Override
    public int limit() {
        return 1000;
    }

    @Override
    public void handle(int money) {
        System.out.println("组长批复报销"+money+"元");
    }   
}

主管审批范围：

public class DirectorLeader extends Leader {

    @Override
    public int limit() {
        return 5000;
    }

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

}

经理审批范围：

public class Manager extends Leader {

    @Override
    public int limit() {
        return 10000;
    }

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

}

老板审批范围：

public class Boss extends Leader {

    @Override
    public int limit() {
        return Integer.MAX_VALUE;
    }

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

}

客户端进行决定谁去审批

public class Client {

    public static void main(String[] args) {
        // 处理对象
        GroupLeader h1 = new GroupLeader();
        DirectorLeader h2 = new DirectorLeader();
        Manager h3 = new Manager();
        Boss h4 = new Boss();

        // 指定下一个处理对象
        h1.nextHandler = h2;
        h2.nextHandler = h3;
        h3.nextHandler = h4;

        h1.handleRequest(5100);
    }

}

以上便是职责链模式的基本使用了~