Responsibility chain mode -- through interview

Introduction

Xiaoshuai company HR Interview process for technicians of Xiaoshuai design company . The interview designed at the beginning is divided into three rounds , The first round is a technical interview , The second round is a written test , The third round is the boss interview .

More and more people come to interview later , The staff of the company are nervous , The technical interview can't be arranged , Xiaoshuai is with HR Discuss , Add another round of telephone interview before the technical interview , Make a preliminary screening .HR Let Xiaoshuai keep full flexibility when designing the interview process , You can add... At any time , Delete the interview node , such as , In the future, it may be necessary to add ideological and moral interview links , Cancel the interview with the boss .

Xiaoshuai thinks carefully , This is the responsibility chain model ？

The chain of responsibility model

The chain of responsibility model ： Allows you to send requests along the handler chain . Upon receipt of the request , Each handler can process the request , Or pass it on to the next handler on the chain . The responsibility chain pattern is a behavior design pattern .

Xiaoshuai put the function of interview , It is written down with the responsibility chain model .

Event handling class ：

/** *  Event handling class  */
public abstract class Handler {
    

    /** *  Next handler  */
    protected Handler nextHandler = null;

    /** *  Set up a handler  * @param nextHandler * @return */
    public Handler setNextHandler(Handler nextHandler) {
    
        this.nextHandler = nextHandler;
        return nextHandler;
    }

    /** *  Treatment method  * @param abilityValue  The ability value of the interviewer  */
    public abstract void handle(int abilityValue);
}

Telephone interview ：

/** *  Telephone interview  */
public class TelephoneInterviewHandler extends Handler{
    

    /** *  Qualified capacity value  */
    final static int PASS_ABILITY_VALUE = 60;

    /** *  Treatment method  */
    @Override
    public void handle(int abilityValue) {
    
        if(abilityValue > PASS_ABILITY_VALUE) {
    
            System.out.println(" The telephone interview passed .");
            if(nextHandler != null) {
    
                nextHandler.handle(abilityValue);
            } else {
    
                System.out.println(" Successful entry ！");
            }
        } else {
    
            System.out.println(" Telephone interview failed .");
        }
    }
}

Face to face interview ：

/** *  Face to face interview  */
public class FaceInterviewHandler extends Handler{
    

    /** *  Qualified capacity value  */
    final static int PASS_ABILITY_VALUE = 70;

    /** *  Treatment method  * * @param abilityValue  Ability value  */
    @Override
    public void handle(int abilityValue) {
    
        if(abilityValue > PASS_ABILITY_VALUE) {
    
            System.out.println(" Pass the face-to-face interview .");
            if(nextHandler != null) {
    
                nextHandler.handle(abilityValue);
            } else {
    
                System.out.println(" Successful entry ！");
            }
        } else {
    
            System.out.println(" Face to face interview failed .");
        }
    }
}

Written examination ：

/** *  written examination  */
public class WrittenTestHandler extends Handler{
    

    /** *  Qualified capacity value  */
    final static int PASS_ABILITY_VALUE = 80;

    /** *  Treatment method  * * @param abilityValue  Ability value  */
    @Override
    public void handle(int abilityValue) {
    
        if(abilityValue > PASS_ABILITY_VALUE) {
    
            System.out.println(" Pass the written examination .");
            if(nextHandler != null) {
    
                nextHandler.handle(abilityValue);
            } else {
    
                System.out.println(" Successful entry ！");
            }
        } else {
    
            System.out.println(" The written examination failed .");
        }
    }
}

Boss interview ：

/** *  Boss interview  */
public class BossInterviewHandler extends Handler{
    

    /** *  Qualified capacity value  */
    final static int PASS_ABILITY_VALUE = 90;

    /** *  Treatment method  * * @param abilityValue  Ability value  */
    @Override
    public void handle(int abilityValue) {
    
        if(abilityValue > PASS_ABILITY_VALUE) {
    
            System.out.println(" The boss passed the interview .");
            System.out.println(" Successful entry ！");
        } else {
    
            System.out.println(" The boss failed in the interview .");
        }
    }
}

Client class ：

/** *  Client class  */
public class Client {
    
    public static void main(String[] args) {
    
        Handler telephoneInterviewHandler = new TelephoneInterviewHandler();
        telephoneInterviewHandler.setNextHandler(new FaceInterviewHandler())
                .setNextHandler(new WrittenTestHandler())
                .setNextHandler(new BossInterviewHandler());
        telephoneInterviewHandler.handle(91);
    }
}

Output ：

 The telephone interview passed .
 Pass the face-to-face interview .
 Pass the written examination .
 The boss passed the interview .
 Successful entry ！

If you don't need a boss interview , Just get rid of the interview with the boss ：

/** *  Client class  */
public class Client {
    
    public static void main(String[] args) {
    
        Handler telephoneInterviewHandler = new TelephoneInterviewHandler();
        telephoneInterviewHandler.setNextHandler(new FaceInterviewHandler())
                .setNextHandler(new WrittenTestHandler());
        telephoneInterviewHandler.handle(85);
    }
}

Output ：

 The telephone interview passed .
 Pass the face-to-face interview .
 Pass the written examination .
 Successful entry ！

summary

When a program needs to process a request in a different way , And the treatment is uncertain , When dynamic adjustment is possible , It is suitable to use the responsibility chain model . This mode can connect multiple processors into a chain , All requests go through the handlers on the chain in strict order , And you can dynamically adjust the handler , newly added , Delete or adjust their order .

advantage

• It can flexibly control the order of request processing and the object of processing .
• Comply with the single responsibility principle , Decouple the client and handler classes .
• Comply with opening and closing principle , You can easily add new processors .

shortcoming

• Some requests may not be processed .
• Increase the complexity of the code , There may be many handler classes .