当接收到一个请求时,可能存在多种解析方式,但是只有一种解析方式能够满足,这个时候我们可以将这些解析方式组织成责任链的模式,让请求在责任链中传递直到找到能够处理该请求的处理器。下面的代码展示的是使用责任链封装的一个简单的日志框架。

1 上代码

抽象日志处理器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    // 责任链中的下一个元素
    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger = nextLogger;
    }
    // 当前打印的日志级别
    public static int LOGGER_LEVEL = INFO;

    public void logMessage(int level, String message){
        if(level <= LOGGER_LEVEL && this.level == level){
            write(message);
        } else if(nextLogger !=null){
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

下面是具体实现的 Info、Debug、Error 级别的日志处理器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class InfoLogger extends AbstractLogger {

    public InfoLogger(){
        this.level = INFO;
        setNextLogger(new DebugLogger());
    }

    @Override
    protected void write(String message) {
        System.out.println("INFO: " + message);
    }
}

public class DebugLogger extends AbstractLogger {

    public DebugLogger(){
        this.level = DEBUG;
        setNextLogger(new ErrorLogger());
    }

    @Override
    protected void write(String message) {
        System.out.println("DEBUG: " + message);
    }
}

public class ErrorLogger extends AbstractLogger {

    public ErrorLogger(){
        this.level = ERROR;
    }

    @Override
    protected void write(String message) {
        System.out.println("ERROR: " + message);
    }
}

对责任链形式的日志框架做一个包装

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class CustomLogger {
    private static AbstractLogger getChainOfLoggers() {
        AbstractLogger infoLogger = new InfoLogger();
        return infoLogger;
    }

    public static CustomLogger getInstance() {
        return new CustomLogger();
    }

    private AbstractLogger logger = getChainOfLoggers();

    public void info(String message) {
        logger.logMessage(AbstractLogger.INFO, message);
    }

    public void debug(String message) {
        logger.logMessage(AbstractLogger.DEBUG, message);
    }

    public void error(String message) {
        logger.logMessage(AbstractLogger.ERROR, message);
    }

}

测试类测试效果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Main {

    public static void main(String[] args) {
        CustomLogger logger = CustomLogger.getInstance();
        // 设置日志级别为 DEBUG
        AbstractLogger.LOGGER_LEVEL = AbstractLogger.DEBUG;
        logger.info("The info message!");
        logger.debug("The debug message!");
        logger.error("The error message!");
    }
}
1
2
INFO: The info message!
DEBUG: The debug message!

可以看到打印出来的日志只有 info 和 debug 没有 error

以上代码是从菜鸟教程的责任链模式改编过来的

参考资料

  1. 菜鸟教程:责任链模式