什么是责任链模式？

为请求创建一个接收的对象链，为请求者和接收者进行解耦。
避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

适用场景

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3、可动态指定一组对象处理请求。
例如：
1、红楼梦中的”击鼓传花”。
2、JS 中的事件冒泡。
3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

代码实现

示例：日志打印就是个很好的责任链模式，发送打印日志请求，各种级别的日志打印对象都接收请求，只有满足级别的对象才打印日志

//示例： 日志打印 打印级别：ERROR>INFO>DEBUG
/**
 * 日志类
 */
abstract class Logger {
    //简化日志级别 假设只有ERRROR>INFO>DEBUG
    public static int DEBUG = 1;
    public static int INFO = 2;
    public static int ERROR = 3;
    //日志级别
    protected int level;
    //责任链中的下一个元素
    protected Logger nextLogger;
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }
    public void log(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.log(level, message);
        }
    }
    abstract protected void write(String message);
}
/**
 * Error级别打印
 */
class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }
    @Override
    protected void write(String message) {
        System.out.println("Error::Logger: " + message);
    }
}
/**
 * INFO级别
 */
class InfoLogger extends Logger {
    public InfoLogger(int level) {
        this.level = level;
    }
    @Override
    protected void write(String message) {
        System.out.println("INFO::Logger: " + message);
    }
}
/**
 * DEBUG级别
 */
class DebugLogger extends Logger {
    public DebugLogger(int level) {
        this.level = level;
    }
    @Override
    protected void write(String message) {
        System.out.println("DEBUG::Logger: " + message);
    }
}
/**
 * 责任链模式 测试
 */
public class ChainofResponsibilityPattern {
    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();
        loggerChain.log(Logger.DEBUG, "This is a debug level information.");
        System.out.println("-------------");
        loggerChain.log(Logger.INFO, "This is an information.");
        System.out.println("-------------");
        loggerChain.log(Logger.ERROR, "This is an error information.");
        System.out.println("-------------");
        //输出：
        //DEBUG::Logger: This is a debug level information.
        //-------------
        //INFO::Logger: This is an information.
        //DEBUG::Logger: This is an information.
        //-------------
        //Error::Logger: This is an error information.
        //INFO::Logger: This is an error information.
        //DEBUG::Logger: This is an error information.
        //-------------
    }
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger debugLogger = new DebugLogger(Logger.DEBUG);
        Logger infoLogger = new InfoLogger(Logger.INFO);
        errorLogger.setNextLogger(infoLogger);
        infoLogger.setNextLogger(debugLogger);
        return errorLogger;
    }
}