责任链模式

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

下面做了一个责任链模式的小案例，大概内容是：我饿了，想让家里人给我做饭。

次序：妈妈->爸爸->爷爷->奶奶->外卖->我自己做饭。结尾，如果都很忙，那我自己做饭。

在责任链模式中，我发出请求后，这个链上的任何人都有机会处理这个请求，如果某一个人没有解决该请求，则会将请求传递给下一个处理者，直到请求被解决，需要注意，设计责任链时，如果一个到了链的末端依然没有解决，这种情况不应该出现，设计时应该注意。

/**
 * @Date 2022/1/13 22:15
 * @Description 外卖类
 **/
public class Waimai extends Handler {

    public Waimai(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(this.isBusy()){
            successor.setBusy(false);
            setSuccessor(this.successor);
            System.out.println("外卖：您的前面有300人排队，大约需要等待2小时");
        }else {
            System.out.println("外卖：已接单，您的外卖正在处理中……");
            setBusy(false);
        }
    }
}

/**
 * @Date 2022/1/13 21:13
 * @Description 自己类
 **/
    public class My extends Handler {

    public My(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(this.isBusy()){
            setSuccessor(successor);
        }else {
            System.out.println("我：正是订饭高峰期，那我自己做饭吧");
        }
    }
}

/**
 * @Date 2022/1/13 20:48
 * @Description 奶奶类
 **/
public class Grandmather extends Handler {
    public Grandmather(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(isBusy()){
            System.out.println("奶奶：我没空，你自己订外卖吧");
            setSuccessor(successor);
        }else{
            System.out.println("行，奶奶给你做饭");
            successor.setBusy(false);
        }
    }
}

/**
 * @Date 2022/1/13 20:48
 * @Description 爷爷类
 **/
public class Grandfather extends Handler{

    public Grandfather(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(isBusy()){
            System.out.println("爷爷：我没空找你奶奶");
            setSuccessor(successor);
        }else{
            System.out.println("行，爷爷给你做饭");
            successor.setBusy(false);
        }
    }
}

/**
 * @Date 2022/1/13 20:47
 * @Description 爸爸类
 **/
public class Father extends Handler {

    public Father(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(isBusy()){
            System.out.println("爸：我没空找你爷爷");
            setSuccessor(successor);
        }else{
            System.out.println("行，爸给你做饭");
            successor.setBusy(false);
        }
    }
}

/**
 * @Date 2022/1/13 20:47
 * @Description 妈妈类
 **/
public class Mather extends Handler {

    public Mather(boolean isBusy){
        setBusy(isBusy);
    }

    @Override
    public void handerRequest() {
        if(isBusy()){
            System.out.println("妈：我没空找你爸");
            setSuccessor(successor);
        }else{
            System.out.println("行，妈给你做饭");
            successor.setBusy(false);
        }
    }
}

main方法 

/**
 * @Date 2022/1/13 20:44
 * @Description 责任链模式的例子，内容：
 * 我饿了，
 * 先找妈妈做饭，
 *      如果妈妈有时间，她给我做饭。
 * 如果妈妈没有时间，让我找爸爸做饭。
 *      如果爸爸有时间，他给我做饭。
 * 如果爸爸没有时间，让我找爷爷做饭。
 *      如果爷爷有时间，他给我做饭。
 * 如果爷爷没有时间，让我找奶奶做饭。
 *      如果奶奶有时间，他给我做饭。
 * 如果奶奶没有时间，让我找自己定外卖。
 *      如果正是午饭时期，订单排队人数较多。
 * 那我自己做饭。
 **/
public class Domain {
    private final static String content = "我饿了";
    public static void main(String[] args) {
        condition2();
    }

    private static void condition2() {
        List<Handler> handlers = getHandlers();
        for (Handler handler : handlers) {
            handler.handerRequest();
            if(!handler.isBusy()){
                break;
            }
        }
    }

    private static List<Handler> getHandlers() {
        List<Handler> handlers = new LinkedList<>();

        Mather mather = new Mather(true);

        Father father = new Father(true);

        Grandfather grandfather = new Grandfather(true);

        Grandmather grandmather = new Grandmather(true);

        Waimai waimai = new Waimai(true);

        My my = new My(false);


        mather.setSuccessor(father);
        father.setSuccessor(grandfather);
        grandfather.setSuccessor(grandmather);
        grandmather.setSuccessor(my);
        my.setSuccessor(waimai);
        waimai.setSuccessor(my);

        handlers.add(mather);
        handlers.add(father);
        handlers.add(grandfather);
        handlers.add(grandmather);
        handlers.add(waimai);
        handlers.add(my);

        return handlers;
    }
}

以下为输出的结果：