责任链模式

责任链模式（Chain of Responsibility Pattern）属于行为型模式。
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

下面的demo为我们常见的log打印：

定义Log责任链的接口：

public abstract class Log {
    // log等级
    public static int INFO = 1;
    public static int WARN = 2;
    public static int ERROR = 3;

    protected Log nextLogger;
    protected int level;

    // 设置下一个处理Log的对象是哪一个
    public void setNextLogger(Log abstractLogger) {
        this.nextLogger = abstractLogger;
    }

    // 处理log
    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        // 调用下一个处理Log的对象
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    public abstract void write(String message);
}

具体的log：

public class InfoLog extends Log {
    public InfoLog(int lever) {
        this.level = lever;
    }
    @Override
    public void write(String message) {
        System.out.println("InfoLogger: " + message);
    }
}

public class WarnLog extends Log {
    public WarnLog(int lever) {
        this.level = lever;
    }
    @Override
    public void write(String message) {
        System.out.println("WarnLogger: " + message);
    }
}

public class ErrorLog extends Log {
    public ErrorLog(int lever) {
        this.level = lever;
    }
    @Override
    public void write(String message) {
        System.out.println("ErrorLog: " + message);
    }
}

设置责任链调用的顺序：

public class LogUtil {
    protected static Log getLog() {
        InfoLog infoLog = new InfoLog(Log.INFO);
        WarnLog warnLog = new WarnLog(Log.WARN);
        ErrorLog errorLog = new ErrorLog(Log.ERROR);
        infoLog.setNextLogger(warnLog);
        warnLog.setNextLogger(errorLog);
        return infoLog;
    }
}

调用：

Log log = LogUtil.getLog();
log.logMessage(Log.INFO, "没有问题");
log.logMessage(Log.WARN, "有点问题");
log.logMessage(Log.ERROR, "出大问题了");

输出结果：

InfoLogger: 没有问题
InfoLogger: 有点问题
WarnLogger: 有点问题
InfoLogger: 出大问题了
WarnLogger: 出大问题了
ErrorLog: 出大问题了

优点：将请求的发送者和请求的处理者解耦。责任链上的处理者负责处理请求，调用时只需要将请求发送到职责链上，不用关心请求的处理细节和传递，并且增加新的请求处理类很方便。