引子

小帅公司的HR找小帅设计公司技术人员的面试流程。刚开始设计的面试分为三轮，第一轮是技术面试，第二轮是笔试，第三轮是老板面试。

后面随着来面试的人越来越多，公司的人员紧张，技术面试都安排不过来了，小帅就和HR商量，在技术面试之前再加一轮电话面试，做个初步筛选。

HR让小帅设计面试流程的时候要保持充分的弹性，可以随时添加，删除面试的节点，比如，以后可能还需要增加思想品德的面试环节，取消老板面试的环节等等。

小帅仔细一想，这不就是责任链模式吗？

责任链模式

责任链模式：允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。责任链模式是一种行为设计模式。

小帅把面试的功能，用责任链模式写了下来了。

事件处理类：

/**
 * 事件处理类
 */
public abstract class Handler {

    /**
     * 下一个处理者
     */
    protected Handler nextHandler = null;

    /**
     * 设置一下个处理者
     * @param nextHandler
     * @return
     */
    public Handler setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
        return nextHandler;
    }

    /**
     * 处理的方法
     * @param abilityValue 面试者的能力值
     */
    public abstract void handle(int abilityValue);
}

电话面试类：

/**
 * 电话面试
 */
public class TelephoneInterviewHandler extends Handler{

    /**
     * 合格能力值
     */
    final static int PASS_ABILITY_VALUE = 60;

    /**
     * 处理的方法
     */
    @Override
    public void handle(int abilityValue) {
        if(abilityValue > PASS_ABILITY_VALUE) {
            System.out.println("电话面试通过。");
            if(nextHandler != null) {
                nextHandler.handle(abilityValue);
            } else {
                System.out.println("成功入职！");
            }
        } else {
            System.out.println("电话面试失败。");
        }
    }
}

当面面试类：

/**
 * 当面面试
 */
public class FaceInterviewHandler extends Handler{

    /**
     * 合格能力值
     */
    final static int PASS_ABILITY_VALUE = 70;

    /**
     * 处理的方法
     *
     * @param abilityValue 能力值
     */
    @Override
    public void handle(int abilityValue) {
        if(abilityValue > PASS_ABILITY_VALUE) {
            System.out.println("当面面试通过。");
            if(nextHandler != null) {
                nextHandler.handle(abilityValue);
            } else {
                System.out.println("成功入职！");
            }
        } else {
            System.out.println("当面面试失败。");
        }
    }
}

笔试类：

/**
 * 笔试
 */
public class WrittenTestHandler extends Handler{

    /**
     * 合格能力值
     */
    final static int PASS_ABILITY_VALUE = 80;

    /**
     * 处理的方法
     *
     * @param abilityValue 能力值
     */
    @Override
    public void handle(int abilityValue) {
        if(abilityValue > PASS_ABILITY_VALUE) {
            System.out.println("笔试通过。");
            if(nextHandler != null) {
                nextHandler.handle(abilityValue);
            } else {
                System.out.println("成功入职！");
            }
        } else {
            System.out.println("笔试失败。");
        }
    }
}

老板面试类：

/**
 * 老板面试
 */
public class BossInterviewHandler extends Handler{

    /**
     * 合格能力值
     */
    final static int PASS_ABILITY_VALUE = 90;

    /**
     * 处理的方法
     *
     * @param abilityValue 能力值
     */
    @Override
    public void handle(int abilityValue) {
        if(abilityValue > PASS_ABILITY_VALUE) {
            System.out.println("老板面试通过。");
            System.out.println("成功入职！");
        } else {
            System.out.println("老板面试失败。");
        }
    }
}

客户端类：

/**
 * 客户端类
 */
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);
    }
}

输出：

电话面试通过。
当面面试通过。
笔试通过。
老板面试通过。
成功入职！

如果不需要老板面试，直接去掉老板面试环节就行：

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

输出：

电话面试通过。
当面面试通过。
笔试通过。
成功入职！

总结

当程序需要用不同的方式处理请求，而且处理方式不确定，可能动态调整的时候，就适合使用责任链模式。

该模式能将多个处理者连接成一条链，所有请求都会严格按照顺序通过链上的处理者，而且你还可以动态的调整处理者，新增，删除或调整它们的顺序。

优点

• 可以灵活控制请求处理的顺序和处理的对象。
• 符合单一职责原则，使得客户端和处理者类解耦。
• 符合开闭原则，可以方便地新增处理者。

缺点

• 部分请求可能无法被处理。
• 增加了代码的复杂度，可能会出现很多处理者类。