（三）Logback-slf4j日志之常用两种方式打印实现原理_slf4j打印出上一个调用

目录

一、常用类配置项

二、实现原理

1.UML图

2.实现流程图

三、源码分析

1.Logger

2.AppenderAttachableImpl

3.UnsynchronizedAppenderBase

4.OutputStreamAppender

5.ConsoleAppender

6.RollingFileAppender

7.LayoutWrappingEncoder

8.PatternLayout

9.PatternLayoutBase

---

如果对Logback的初始化以及和Springboot的集成感兴趣也可以跳转至下列博客：

1. （一）Logback-slf4j日志原理及源码启动分析
2. （二）Logback-slf4j日志和Springboot集成配置原理

一、常用类配置项

下列是常用的配置，接下来将会基于下面这些配置来分析Logback的打印实现原理：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <contextName>logback</contextName>
    <property name="logging.path" value="F:/springboot-demo/logs"/>
    <property name="pattern" value="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%t] [%level] [%logger{80}] - %m%n"/>
    
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>
 
    <appender name="app" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${logging.path}/app/log-app.log</file>
        <encoder>
            <pattern>${pattern}</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logging.path}/app/log-app-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <TimeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>5MB</maxFileSize>
            </TimeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
    </appender>
    
    <root level="info">
        <appender-ref ref="console"/>
        <appender-ref ref="app"/>
    </root>
</configuration>

二、实现原理

1.UML图

首先看到其主要类的UML图再次了解一下大致结构：

其主要类和第一篇说的差不多，只是在这里贴出了Appender以及搭配使用的Encoder、Layout和Policy等具体实现类。LoggingEvent对象是在Appender以及相关搭配类互相传递的参数，每当调用一次打印日志的方法，都会创建一个LoggingEvent打印事件，具体的打印流程面向的便是这个打印事件。Appender和相关搭配类其具体作用分别为：

1. ILoggingEvent：日志事件接口，其实现类将会承担Logback实现日志打印的数据载体，在不同的组件中传递，并最终交由Converter处理；
2. Appender：所有日志打印和Logger交互的入口，可以理解成日志打印流程的载体，所有的流程都会在这里面实现；
3. Encoder：负责将传入的Log事件转化为一个字节数组；
4. Layout：将会预先解析用户规定的日志格式，并将其转换成一个个Converter，在最终打印时再使用Converter链将日志时间转换成对应的日志内容字符串；
5. Converter：具体实现日志事件转换成字符串的类，一般会组成链式的转换器链，将日志事件转换并写到StringBuilder对象中；
6. TriggeringPolicy：控制了发生日志文件滚动的条件，即滚动触发器。这些条件包括一天中的时间、文件大小、外部事件、日志请求或其组合；
7. RollingPolicy：具体实现日志文件滚动的接口类，当发生滚动时其还会提供活动日志文件（即当前使用的实时日志文件）。

2.实现流程图

Logback的Logger构成类似于一个树状结构，而Logback在实现打印逻辑时也是根据树状结构的特点去实现的。接下来就分析一下ConsoleAppender和RollingFileAppender这两个最常用Appender大致运行流程，其大致流程图如下：

可以从大致流程图看到，Appender和Converter是以链式存在的。Appender的链式表现为从子节点指向父节点最终到ROOT节点，利用了树状结构；而Converter则是普通的链式，以head开头，使用next指向下一个节点，这个链式则是PatternLayout调用start()方法初始化的，具体实现逻辑便不做过多分析。其具体流程分析图如下：

具体的流程便不介绍，看图片即可。

三、源码分析

在第一和第二篇中说明了Logback的关键组成以及对于配置是如何加载的，在本篇中则说明一下平时使用Logback最常用的两类Appender及其实现原理流程。大致的流程分析可看前面的流程图。

1.Logger

实现SLF4J的Logger接口，开发者使用Logback打印日志的交互类。接下来我们以调用info()和error()两个打印日志方法来一探究竟：

public final class Logger implements org.slf4j.Logger, LocationAwareLogger,
        AppenderAttachable<ILoggingEvent>, Serializable {
    // Logger的名字
    private String name;
    // 当前的Logger日志级别Level对象，不能为空
    transient private Level level;
    // 当前Logger的Level int值，可为空，如果为空则取父类的值
    transient private int effectiveLevelInt;
    // 父节点Logger
    transient private Logger parent;
    // 子节点系列Logger
    transient private List<Logger> childrenList;
    // 处理当前Logger日志处理器Appender集合
    transient private AppenderAttachableImpl<ILoggingEvent> aai;
    // 当从子节点开始往父节点遍历时，如果additive为false则代表遍历到此结束
    transient private boolean additive = true;
    // 接下来只贴出info()和error()方法，且参数都是3或以上的方法
    // 如果参数是1或者2，最终还是会转换成3或以上的处理方式，因此直接贴3或以上的
    public void info(String format, Object... argArray) {
        // 如果是打印info级别日志，Level对象直接传Level.INFO，如果是打印warn
        // 或者其它级别的日志则方法里面会传对应的级别，调用的其实都是同样的方法
        filterAndLog_0_Or3Plus(FQCN, null, Level.INFO, format, argArray, 
                null);
    }
    public void error(String format, Object... argArray) {
        // 如果是打印error级别日志，Level对象直接传Level.ERROR
        filterAndLog_0_Or3Plus(FQCN, null, Level.ERROR, format, argArray, 
                null);
    }
    private void filterAndLog_0_Or3Plus(final String localFQCN, 
            final Marker marker, final Level level, final String msg, 
            final Object[] params,
            final Throwable t) {
        // 3或者三个以上的参数最终都会调用到这个方法中，只是Level对象会变成
        // 对应的日志级别对象
        // 调用TurboFilterList判断，一般用不到，因此暂不分析，等改日有时间再
        // 对其进行研究
        final FilterReply decision = loggerContext
                .getTurboFilterChainDecision_0_3OrMore(marker, this, 
                        level, msg, params, t);
        // FilterReply分为三种：NEUTRAL、DENY和ACCEPT
        if (decision == FilterReply.NEUTRAL) {
            if (effectiveLevelInt > level.levelInt) {
                return;
            }
        } else if (decision == FilterReply.DENY) {
            return;
        }
        // 如果没使用特殊的TurboFilter处理最终会调用到这里
        buildLoggingEventAndAppend(localFQCN, marker, level, msg, params, 
                t);
    }
    private void buildLoggingEventAndAppend(final String localFQCN, 
            final Marker marker, final Level level, final String msg, 
            final Object[] params,
            final Throwable t) {
        // 不管是什么级别的日志打印方法，最终都会调用到这里来，在这里根据传进来的
        // 参数创建LoggingEvent日志事件
        LoggingEvent le = new LoggingEvent(localFQCN, this, level, msg, t, 
                params);
        le.setMarker(marker);
        // 开始调用本Logger中的Appender集合处理日志事件
        callAppenders(le);
    }
    public void callAppenders(ILoggingEvent event) {
        // 当有一个Appender成功处理日志事件时，writes将会+1
        int writes = 0;
        // 从当前节点往父节点依次遍历，直到ROOT节点
        for (Logger l = this; l != null; l = l.parent) {
            // 一个Logger可能会有多个Appender处理日志事件，对应的操作便是一个
            // Logger可能会有ConsoleAppender也会有FileAppender
            writes += l.appendLoopOnAppenders(event);
            // 为false代表遍历到此结束，不再往上遍历
            if (!l.additive) {
                break;
            }
        }
        // 如果没有Appender处理当前日志事件
        if (writes == 0) {
            // 这个方法实际上会打印"No appenders present in context [] 
            // for logger []."，最常见的便是Zookeeper在log4j中的报错也是
            // 类似于这个原因
            loggerContext.noAppenderDefinedWarning(this);
        }
    }
    private int appendLoopOnAppenders(ILoggingEvent event) {
        if (aai != null) {
            // 如果aai对象Appender集合不为空则调用
            return aai.appendLoopOnAppenders(event);
        } else {
            return 0;
        }
    }
}

跟踪主要代码看起来其实打印日志在Logger中没有经理很多流程，只是大致封装了一下日志事件来调用Appender实现打印日志到控制台或者文件或者其它的地方。

2.AppenderAttachableImpl

用于将Appender和对象绑定起来的实现类，实现的功能便是将Appender和具体的Logger关联起来，其在流程中的主要代码如下：

public class AppenderAttachableImpl<E> implements AppenderAttachable<E> {
    // 包含封装的Appender对象
    final private COWArrayList<Appender<E>> appenderList = 
            new COWArrayList<Appender<E>>(new Appender[0]);
    public void addAppender(Appender<E> newAppender) {
        // 在AppenderAttachableImpl被创建时需要添加Appender到appenderList中
        // 便是通过调用这个方法完成的，如果是XML配置方式可看到AppenderRefAction
        if (newAppender == null) {
            throw new IllegalArgumentException("Null argument disallowed");
        }
        appenderList.addIfAbsent(newAppender);
    }
    public int appendLoopOnAppenders(E e) {
        int size = 0;
        final Appender<E>[] appenderArray = appenderList.asTypedArray();
        final int len = appenderArray.length;
        // 转换成数组依次遍历，调用Appender的doAppend()方法处理，处理成功则
        // size+1，标示着有多少个Appender处理了日志事件
        for (int i = 0; i < len; i++) {
            appenderArray[i].doAppend(e);
            size++;
        }
        return size;
    }
}

从官方对这个对象的定位就可以知道，这个类只是一个中介类，为了实现Appender和Logger关联而存在的，因此这个类中没有很多实际的逻辑。

3.UnsynchronizedAppenderBase

这个Appender抽象类是接下来要分析的ConsoleAppender和RollingFileAppender的共同父类，子类实现逻辑的调用入口也是从这个类调用进去的，其源码如下：

abstract public class UnsynchronizedAppenderBase<E> 
        extends ContextAwareBase implements Appender<E> {
    // 是否调用start()方法成功
    protected boolean started = false;
    // 守卫，用来保证一个线程只会有一个请求进来
    private ThreadLocal<Boolean> guard = new ThreadLocal<Boolean>();
    public void doAppend(E eventObject) {
        // 如果为TRUE则代表守卫开始工作，不会允许同一个线程同时有两个进来
        if (Boolean.TRUE.equals(guard.get())) {
            return;
        }
        try {
            // 守卫开始工作
            guard.set(Boolean.TRUE);
            if (!this.started) {
                if (statusRepeatCount++ < ALLOWED_REPEATS) {
                    // 没有启动成功
                }
                return;
            }
            // 再次判断tFilter，一般用不到，暂不分析
            if (getFilterChainDecision(eventObject) == FilterReply.DENY) {
                return;
            }
            // 开始调用子类的append方法进行日志处理
            this.append(eventObject);
        } catch (Exception e) {
            if (exceptionCount++ < ALLOWED_REPEATS) {
                addError("Appender [" + name + "] failed to append.", e);
            }
        } finally {
            // 守卫工作完了，结束工作
            guard.set(Boolean.FALSE);
        }
    }
    abstract protected void append(E eventObject);
}

相当于使用模板方法把处理日志的方法进行了改变。

4.OutputStreamAppender

面向流的父类，是ConsoleAppender、FileAppender和RollingFileAppender这三个需要使用到流的共同父类。其源码如下：

public class OutputStreamAppender<E> extends UnsynchronizedAppenderBase<E>{
    // 最终负责将日志事件转变成流所需要的byte[]数组对象
    protected Encoder<E> encoder;
    protected final ReentrantLock lock = new ReentrantLock(false);
    // 管理维护的流对象
    private OutputStream outputStream;
    // 是否立即将流的数据刷到文件中
    boolean immediateFlush = true;
    @Override
    protected void append(E eventObject) {
        if (!isStarted()) {
            return;
        }
        // 这个方法子类可以重写
        subAppend(eventObject);
    }
    protected void subAppend(E event) {
        // 就我们使用的ConsoleAppender、FileAppender和RollingFileAppender
        // 三个Appender而言，最终都会调用到这个方法中来
        if (!isStarted()) {
            return;
        }
        try {
            // 调用该方法来防止日志事件没有初始化的问题
            // prepareForDeferredProcessing()将会将需要打印日志的格式填充
            // 并获取线程名称和MDC属性集合
            if (event instanceof DeferredProcessingAware) {
                ((DeferredProcessingAware) event)
                        .prepareForDeferredProcessing();
            }
            // 调用encoder的encode()方法将日志事件转换成byte[]数组，Converter
            // 链也是在这个方法中完成的，稍后分析
            byte[] byteArray = this.encoder.encode(event);
            // 将字节数组写入到流对象中
            writeBytes(byteArray);
        } catch (IOException ioe) {
            this.started = false;
            addStatus(new ErrorStatus("IO failure in appender",this,ioe));
        }
    }
    private void writeBytes(byte[] byteArray) throws IOException {
        // 写入的对象为空则直接返回
        if(byteArray == null || byteArray.length == 0)
            return;
        lock.lock();
        try {
            // 将数据写入到流中
            this.outputStream.write(byteArray);
            if (immediateFlush) {
                // 立刻刷新到流中
                this.outputStream.flush();
            }
        } finally {
            lock.unlock();
        }
    }
}

通过这个类先了解写入流中的最终操作，其它三个实现类的具体处理都是在子类通过增加额外的功能完成的，因此这个可以看成是公共基础部分。

5.ConsoleAppender

这个Appender将会使用用户指定的日志格式将日志事件附加在System.out或者Sytem.err对象流中，默认的流是System.out。代码如下：

public class ConsoleAppender<E> extends OutputStreamAppender<E> {
    // 默认的流对象，实际上指向的是System.out
    protected ConsoleTarget target = ConsoleTarget.SystemOut;
    @Override
    public void start() {
        // 通过调用start()方法来设置父类的流对象
        OutputStream targetStream = target.getStream();
        // enable jansi only on Windows and only if withJansi set to true
        if (EnvUtil.isWindows() && withJansi) {
            targetStream = getTargetStreamForWindows(targetStream);
        }
        // 设置父类的新流对象，老的流将会关闭
        setOutputStream(targetStream);
        super.start();
    }
}

该类的作用基本上就是将System.out和System.err控制台的流替换到父类的流对象中。

6.RollingFileAppender

这是FileAppender的子类，集成FileAppender功能的同时，提供可滚动文件的额外功能。其代码如下：

public class RollingFileAppender<E> extends FileAppender<E> {
    // 当前活动的文件
    File currentlyActiveFile;
    // 触发滚动条件的判断类
    TriggeringPolicy<E> triggeringPolicy;
    // 实现具体滚动逻辑的滚动类
    RollingPolicy rollingPolicy;
    @Override
    protected void subAppend(E event) {
        // 判断当前的日志对象是否满足滚动条件，如果满足则调用rollover()
        // 方法进行文件滚动
        synchronized (triggeringPolicy) {
            if (triggeringPolicy.isTriggeringEvent(currentlyActiveFile, 
                    event)){
                rollover();
            }
        }
        // 调用父类的方法，实际上是OutputStreamAppender的方法
        super.subAppend(event);
    }
    public void rollover() {
        lock.lock();
        try {
            // 关闭当前流对象
            this.closeOutputStream();
            // 尝试使用rollingPolicy对象滚动文件
            attemptRollover();
            // 尝试打开滚动后文件的流
            attemptOpenFile();
        } finally {
            lock.unlock();
        }
    }
    private void attemptRollover() {
        try {
            // 滚动文件
            rollingPolicy.rollover();
        } catch (RolloverFailure rf) {
            this.append = true;
        }
    }
    private void attemptOpenFile() {
        try {
            // 获取rollingPolicy的活动文件，并设置给currentlyActiveFile对象
            currentlyActiveFile = new File(
                    rollingPolicy.getActiveFileName());
            // 尝试打开文件并获取文件流设置给outputStream对象
            this.openFile(rollingPolicy.getActiveFileName());
        } catch (IOException e) {
            addError("setFile(" + fileName + ", false) call failed.", e);
        }
    }
}

对于具体rollingPolicy和triggeringPolicy的实现方式又有很多方式，具体的实现逻辑暂不分析，但是根据平时使用的结果来看无非是根据命名规则创建一个新的文件，并将老的日志内容移到新的文件中，又或者是更改命名字节创建新的日志文件，大同小异。

7.LayoutWrappingEncoder

听名字就可以看出来这是一个封装类，实际上这里面封装了一个Layout实现类，具体的转换是在Layout实现类完成的。其代码如下：

public class LayoutWrappingEncoder<E> extends EncoderBase<E> {
    protected Layout<E> layout;
    public byte[] encode(E event) {
        // 直接调用layout对象的doLayout()方法对日志时间进行转换
        String txt = layout.doLayout(event);
        // 再将String转换成byte[]数组
        return convertToBytes(txt);
    }
    private byte[] convertToBytes(String s) {
        if (charset == null) {
            return s.getBytes();
        } else {
            // 如果有规定charset则使用charset转换
            return s.getBytes(charset);
        }
    }
}

8.PatternLayout

对日志样式进行转换的类，实际上可以看成是对Converter的管理类，当有日志事件进来时直接调用Converter链来进行转换。其代码如下：

public class PatternLayout extends PatternLayoutBase<ILoggingEvent> {
    // 用来存储当前日志样式对照表
    public static final Map<String, String> defaultConverterMap = 
            new HashMap<String, String>();
    static {
        // 这里显示了当前样式所支持的一些配置，包括缩写和全称，这也是为什么
        // 我们的Pattern要按照这些来配
        defaultConverterMap.putAll(Parser.DEFAULT_COMPOSITE_CONVERTER_MAP);
    
        defaultConverterMap.put("d", DateConverter.class.getName());
        defaultConverterMap.put("date", DateConverter.class.getName());
    
        defaultConverterMap.put("r", 
                RelativeTimeConverter.class.getName());
        defaultConverterMap.put("relative", 
                RelativeTimeConverter.class.getName());
    
        defaultConverterMap.put("level", LevelConverter.class.getName());
        defaultConverterMap.put("le", LevelConverter.class.getName());
        defaultConverterMap.put("p", LevelConverter.class.getName());
    
        defaultConverterMap.put("t", ThreadConverter.class.getName());
        defaultConverterMap.put("thread", ThreadConverter.class.getName());
    
        defaultConverterMap.put("lo", LoggerConverter.class.getName());
        defaultConverterMap.put("logger", LoggerConverter.class.getName());
        defaultConverterMap.put("c", LoggerConverter.class.getName());
    
        defaultConverterMap.put("m", MessageConverter.class.getName());
        defaultConverterMap.put("msg", MessageConverter.class.getName());
        defaultConverterMap.put("message", 
                MessageConverter.class.getName());
    
        defaultConverterMap.put("C", 
                ClassOfCallerConverter.class.getName());
        defaultConverterMap.put("class", 
                ClassOfCallerConverter.class.getName());
    
        defaultConverterMap.put("M", 
                MethodOfCallerConverter.class.getName());
        defaultConverterMap.put("method", 
                MethodOfCallerConverter.class.getName());
    
        defaultConverterMap.put("L", 
                LineOfCallerConverter.class.getName());
        defaultConverterMap.put("line", 
                LineOfCallerConverter.class.getName());
    
        defaultConverterMap.put("F", 
                FileOfCallerConverter.class.getName());
        defaultConverterMap.put("file", 
                FileOfCallerConverter.class.getName());
    
        defaultConverterMap.put("X", MDCConverter.class.getName());
        defaultConverterMap.put("mdc", 
                MDCConverter.class.getName());
    
        defaultConverterMap.put("n", 
                LineSeparatorConverter.class.getName());
    }
    public String doLayout(ILoggingEvent event) {
        if (!isStarted()) {
            return CoreConstants.EMPTY_STRING;
        }
        // 这个方法是父类的，可直接看到父类实现
        return writeLoopOnConverters(event);
    }
}

PatternLayout从方法调用层面来看是没什么作用的，但其主要作用并不是用来处理运行时的逻辑，而是提供Pattern样式格式对应的Converter处理器。我们平时使用的各种格式符号规则便来源于此。

9.PatternLayoutBase

刚刚所说的PatternLayout只是为样式分析提供对应的Converter，而PatternLayoutBase则是真正调用处理样式的地方。代码如下：

abstract public class PatternLayoutBase<E> extends LayoutBase<E> {
    // Converter调用链的头节点
    Converter<E> head;
    public void start() {
        // 这个start()方法的作用便是解析一开始的Pattern日志格式
        if (pattern == null || pattern.length() == 0) {
            addError("Empty or null pattern.");
            return;
        }
        try {
            // 创建解析器
            Parser<E> p = new Parser<E>(pattern);
            if (getContext() != null) {
                p.setContext(getContext());
            }
            Node t = p.parse();
            // getEffectiveConverterMap()方法最终会调用子类的Converter
            // 对照表，从而根据编译出Pattern一串Converter链表
            this.head = p.compile(t, getEffectiveConverterMap());
            if (postCompileProcessor != null) {
                postCompileProcessor.process(context, head);
            }
            // 对Converter进行初始化等操作
            ConverterUtil.setContextForConverters(getContext(), head);
            ConverterUtil.startConverters(this.head);
            super.start();
        } catch (ScanException sce) {
            StatusManager sm = getContext().getStatusManager();
            sm.add(new ErrorStatus("Failed to parse pattern \"" + 
                    getPattern() + "\".", this, sce));
        }
    }
    protected String writeLoopOnConverters(E event) {
        // Converter处理结果写入对象，看方法也可以知道这个方法的作用就是
        // 循环遍历Converter进行写入操作
        StringBuilder strBuilder = 
                new StringBuilder(INTIAL_STRING_BUILDER_SIZE);
        Converter<E> c = head;
        // 开始遍历Converter链来处理当前日志对象
        while (c != null) {
            c.write(strBuilder, event);
            c = c.getNext();
        }
        // 返回处理结果
        return strBuilder.toString();
    }
}

至此，Logback的常用两种打印方式便分析完了，其它的Appender功能以后有机会再来分析分析。