责任链模式

责任链模式重在一个链上，处理一件事要经过层层审批才能执行，或者在我请求某件事之前要有很多对象需要给我的请求添加更多参数
类图如下

责任链模式类图

假设一种场景，古代妇女的地位比较低，做什么事情都要请求男人，也就是父亲，丈夫，儿子其中有一个处理了这个请求才能去做
1，妇女的抽象类

public interface Women {
    //当前个人状态
    int getType();
    //请示内容
    String getRequest();
}

2，妇女的具体实现类

public class WomenA implements Women{
    /**
     * 妇女个人状况
     * 1--未出嫁
     * 2--出嫁
     * 3--夫死
     */
    private int type= 0;

    /**
     * 夫死
     */
    private String request = "";


    public WomenA(int type,String request){
        this.type = type;
        this.request = request;
    }


    @Override
    public int getType() {
        return this.type;
    }

    @Override
    public String getRequest() {
        return this.request;
    }
}

3，处理请求的抽象类

/**
 * 控制权对象
 */
public abstract class Handler {

    public final static int REQUEST_FATHER = 1;
    public final static int REQUEST_HUSBAND = 2;
    public final static int REQUEST_SON = 3;

    //能处理的级别
    private int level = 0;
    //责任传递，下一个责任人是谁
    private Handler nextHandler;

    public Handler(int level){
        this.level = level;
    }

    public final void handleMessage(Women women){
        if (women.getType() == this.level){
            this.response(women);
        } else {
            if (this.nextHandler != null){
                this.nextHandler.handleMessage(women);
            } else {
                System.out.println("----没地方请示了，按不同意处理-----");
            }
        }
    }

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

    protected abstract void response(Women women);
}

4，各个处理对象，父亲，丈夫，儿子

public class Father extends Handler {

    public Father() {
        super(Handler.REQUEST_FATHER);
    }

    @Override
    protected void response(Women women) {
        System.out.println("\n-------------女儿向父亲请示------------");
        System.out.println("女儿的请示是：" + women.getRequest());
        System.out.println("父亲的回到是：同意");
    }
}


public class Husband extends Handler{

    public Husband() {
        super(Handler.REQUEST_HUSBAND);
    }

    @Override
    protected void response(Women women) {
        System.out.println("\n-------------妻子向丈夫请示------------");
        System.out.println("妻子的请示是：" + women.getRequest());
        System.out.println("丈夫的回到是：同意");
    }
}

public class Son extends Handler{

    public Son() {
        super(Handler.REQUEST_SON);
    }

    @Override
    protected void response(Women women) {
        System.out.println("\n-------------母亲向儿子请示------------");
        System.out.println("母亲的请示是：" + women.getRequest());
        System.out.println("儿子的回到是：同意");
    }
}

5，调用

public class Main {
    public static void main(String[] args){
        Random random = new Random();
        ArrayList<Women> arrayList = new ArrayList<>();
        for (int i =0 ;i<5;i++){
            arrayList.add(new WomenA(random.nextInt(4),"我要出去逛逛"));
        }
        Handler father = new Father();
        Handler husband = new Husband();
        Handler son = new Son();

        father.setNext(husband);
        husband.setNext(son);
        for (Women women:arrayList){
            father.handleMessage(women);
        }
    }
}

总结：
最主要的类就是Handler类，它负责设置请求级别，如果自己请求不了递交给他的下级，设置他的下级，处理请求的抽象
handleMessage为final子类不可以修改，子类要处理请求需要实现继承Handler，设置自己的处理级别，并且实现抽象response用来处理请求

责任链模式将处理和请求分开，调用者不需要知道是谁处理的，同样处理者也不需要知道请求者的全貌
可能引发的问题是链过长导致的性能下降

工作中我们使用的责任链的场景很多，比如在贷款场景中，我点击马上用钱需要进行一系列的校验，是否登录-->是否实名-->是否填写联系人-->是否验证运营商-->是否添加基本信息-->是否添加银行卡，其中哪一项不满足条件都需要跳转到相应的不同页面进行验证。这就是典型的责任链模式应用场景