1. 基本概念

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。实现了发送者和接收者之间的解耦，属于行为型模式。

2 主要思想

各司其职，职责链上的处理者负责处理请求，客户端只需要将请求发送到职责链上，不用关心接下来的请求传递及请求处理。
主要的实现方式是拦截类都实现统一的接口，方便统一传递。
在处理类Handler中聚合自己，在过滤接口，例如HandlerRequest 中判断是否应该由自己处理，如果不是，继续传递给上层处理。

3. 代码实现

需求：职员Staff 想要请假8天，逐级向上审批，经理可以审批3天内的，总监可以审批7天内的，老板可以审批7天以上的。

 public static void main(String[] args) {
        String msg = "家里有事，请假8天，望批准!";
        Staff staff = new Staff();
        Manager manager = new Manager();
        Director director = new Director();
        Boss boss = new Boss();

        staff.setProcessor(manager);
        manager.setProcessor(director);
        director.setProcessor(boss);

        staff.handler(msg);
    }

}

abstract class Handler {
    Handler processor;
    abstract void handler(String msg);
    abstract void setProcessor(Handler processor);
    abstract Handler getProcessor();
}

class Staff extends Handler {
    private Handler processor;

    @Override
    void handler(String msg) {
        System.out.println("小弟不能自己做主，只能向上申请!");
        this.processor.handler(msg);
    }

    @Override
    void setProcessor(Handler processor) {
        this.processor = processor;
    }

    @Override
    Handler getProcessor() {
        return processor;
    }
}

class Manager extends Handler {
    private Handler processor;

    @Override
    void handler(String msg) {
        System.out.println("我只能审批3天内的，超出3天的范围，需Director审批!");
        this.processor.handler(msg);
    }

    @Override
    void setProcessor(Handler processor) {
        this.processor = processor;
    }

    @Override
    Handler getProcessor() {
        return processor;
    }
}

class Director extends Handler {
    private Handler processor;

    @Override
    void handler(String msg) {
        System.out.println("我只能审批7天内的，超出7天的范围，，需Boss审批!");
        this.processor.handler(msg);
    }

    @Override
    void setProcessor(Handler processor) {
        this.processor = processor;
    }

    @Override
    Handler getProcessor() {
        return processor;
    }
}

class Boss extends Handler {
    private Handler processor;

    @Override
    void handler(String msg) {
        System.out.println("批准!");
    }

    @Override
    void setProcessor(Handler processor) {
        this.processor = processor;
    }

    @Override
    Handler getProcessor() {
        return processor;
    }

运行结果

小弟不能自己做主，只能向上申请!
我只能审批3天内的，超出3天的范围，需Director审批!
我只能审批7天内的，超出7天的范围，，需Boss审批!
批准!

4. 优劣之分

优点：
1、降低耦合度。它将请求的发送者和接收者解耦。
2、简化了对象。使得对象不需要知道链的结构。
3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。

缺点：
1、不能保证请求一定被接收。
2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3、可能不容易观察运行时的特征，有碍于除错。

使用场景：
1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3、可动态指定一组对象处理请求。