【Logback】＜logger＞、＜root＞标签详解

文章目录

• 背景
• 一、\使用
• • 1.1、使用示例
  • 1.1、属性配置说明 & 演示
  • • 1.1.1、name
    • 1.1.2、level
    • 1.1.3、additivity
    • • 1.1.3.1、效果演示：additivity=true
      • 1.1.3.1、效果演示：additivity=”false”
  • 1.2 appender-ref
• 二、\使用
• • 2.1、属性
• 三、解析
• • 3.1、\链表
  • • 3.2、root是一个名为 ROOT 的特殊logger，其 parent 为 null
    • 3.3、 name属性和\继承关系
  • 3.3、level属性继承 和 优先级
  • 3.4、additivity属性
  • • 3.4.1、源码分析
    • 3.4.2、演示
• 四、日志规范
• 五、参考资料

背景

排查一个项目的问题，发现打印了一堆重复日志…，为避免日志爆盘被投诉，写一下logback的使用和解析。 因为重复日志问题引发的，所以本文优先、标签，其余的后续在写…

版本：logback-1.2.3

一、使用

如果需要定制指定模块或者类的日志信息，可以通过标签来实现，通过其name属性指定包或者类全路径即可

是有父子关系的

是一个特殊的 ，其name=”ROOT”，是所有的祖先节点，先了解，下面会讲。

父子关系是根据name属性的层级来确定的

如，其父子关系如下（先了解结论，下面分析中会讲）：

└─

│ └─

│ │ └─

│ │ │ └─

1.1、使用示例

Tips：

1、可以配置 0-N 个

2、由属性和子元素2个部分构成，日志输出是所引用的来执行的

3、本身是一个链表，有一个父节点和N个子节点，具体在1.3、解析中详细说明

1.1、属性配置说明 & 演示

1.1.1、name

指定包或者类全路径，则该的配置就对其生效，默认使用的日志配置

1.1.2、level

日志级别

Tips:

日志级别level属性是有继承关系，其优先级如下（此表摘自logback官网）：

总结：

若自身没设置 level 则使用其父Logger的level

若父级都没设置，则使用节点的，不配置则其默认级别level为DEBUG

1.1.3、additivity

是否允许父级打印自身name指定范围内的日志。若允许，则会重复打印日志。

1.1.3.1、效果演示：additivity=true

1)、打印日志代码

package com.qbhj.logback.controller;
// import .....

@Slf4j
@RestController
public class LogController {
    @GetMapping("/additivity")
    public void additivity(@RequestParam(defaultValue = "1") Integer num) {
        System.out.println("###################################### num: " + num);
        for (int i = 0; i < num; i++) {
            log.info("/additivity......");
        }
    }
}

2.1)、日志配置，只配置root，无

2.2)、结果，日志只打印了一遍

###################################### num: 1
20:36:06.170  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......

2.3)、说明

所有Logger都没有配置appender，所以无日志输出

root配置了appender=CONSOLE，所以控制台会打印日志

3.1)、增加配置name=com.qbhj.logback.controller ，、中都有配置控制台（CONSOLE）输出，共配置了2遍

3.2)、结果，日志打了2遍，是和各自打一遍

###################################### num: 1
20:54:51.165  INFO --- [     http-nio-8080-exec-2] c.qbhj.logback.controller.LogController  : /additivity......
20:54:51.165  INFO --- [     http-nio-8080-exec-2] c.qbhj.logback.controller.LogController  : /additivity......

3.3)、说明

配置了appender=CONSOLE ，控制台打印日志

root配置了appender=CONSOLE，所以控制台会打印日志

4.1)、再增加配置name=com.qbhj.logback logback包肯定包含 LogController类的，即、中都有配置控制台（CONSOLE）输出，共配置了3遍

4.2)、结果，日志打了3遍，2个和各自打一遍

###################################### num: 1
20:58:23.914  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......
20:58:23.914  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......
20:58:23.914  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......

4.3)、说明

2个 配置了appender=CONSOLE ，控制台打印日志2遍

root配置了appender=CONSOLE，控制台会打印日志

1.1.3.1、效果演示：additivity=“false”

1.1)、同样的配置，全部改为additivity=“false”

1.2)、结果：日志只打印了一遍

###################################### num: 1
21:00:24.598  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......

1.3)、说明

，配置了appender=CONSOLE所以打印日志。其additivity=“false”,不调用父级，结束

1.2 appender-ref

示例

1、每个logger可以配置任意（含0）个

2、语法：ref=appender[name]，声明 的name属性值

二、使用

2.1、属性

的本质是一个名为ROOT的特殊logger，即

root是所有logger的根节点

三、解析

3.1、链表

1、是一个链表，有父节点和子节点

2、除父节点为null外，所有logger一定有父节点，为所有logger的根节点

ch.qos.logback.classic.Logger

package ch.qos.logback.classic;
//..........

public final class Logger implements org.slf4j.Logger, LocationAwareLogger, AppenderAttachable, Serializable {
    // ..........

    /**
     * The name of this logger
     */
    private String name;

    // The assigned levelInt of this logger. Can be null.
    transient private Level level;

    // The effective levelInt is the assigned levelInt and if null, a levelInt is
    // inherited form a parent.
    transient private int effectiveLevelInt;


// root 为所有logger的祖先（根）节点
    /**
     * The parent of this category. All categories have at least one ancestor
     * which is the root category.
     */
    transient private Logger parent;

    /**
     * The children of this logger. A logger may have zero or more children.
     */
    transient private List childrenList;

// additive 默认 true
    transient private boolean additive = true;

    final transient LoggerContext loggerContext;
    // ..........
    
    private boolean isRootLogger() {
      // only the root logger has a null parent
// 只有root的parent为null
      return parent == null;
    }
   
    // .......... 
}

3.2、root是一个名为 ROOT 的特殊logger，其 parent 为 null

LoggerContext 初始化的时候就在其构造函数中创建了root了

root默认日志级别为 DEBUG

ch.qos.logback.classic.LoggerContext

public class LoggerContext extends ContextBase implements ILoggerFactory, LifeCycle {

    /** Default setting of packaging data in stack traces */
    public static final boolean DEFAULT_PACKAGING_DATA = false;

    final Logger root;
    private int size;
    private int noAppenderWarning = 0;
    final private List loggerContextListenerList = new ArrayList();

    private Map loggerCache;
    // .............
    public LoggerContext() {
        super();
        this.loggerCache = new ConcurrentHashMap();

        this.loggerContextRemoteView = new LoggerContextVO(this);

// 初始化 
        /**
        package org.slf4j;
        public interface Logger {
            String ROOT_LOGGER_NAME = "ROOT";
        */
        this.root = new Logger(Logger.ROOT_LOGGER_NAME, null, this);
// ROOT的默认日志级别 DEBUG
        this.root.setLevel(Level.DEBUG);

        loggerCache.put(Logger.ROOT_LOGGER_NAME, root);
        initEvaluatorMap();
        size = 1;
        this.frameworkPackages = new ArrayList();
    }
    // .......... 

}

3.3、 name属性和继承关系

1、会根据name属性的值，逐级创建子logger，如com.qbhj.Test.class中 log.info(“print log…”)，一共会创建3个logger

1)、com

2)、com.qbhj

3)、com.qbhj.Test

ch.qos.logback.classic.LoggerContext#getLogger(java.lang.Class)

    public final Logger getLogger(final Class clazz) {
        return getLogger(clazz.getName());
    }
    @Override
    public final Logger getLogger(final String name) {

        if (name == null) {
            throw new IllegalArgumentException("name argument cannot be null");
        }
// root直接返回
        // if we are asking for the root logger, then let us return it without
        // wasting time
        if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) {
            return root;
        }

// 非root，先拿到root，然后逐级创建其子logger
        int i = 0;
        Logger logger = root;

        // check if the desired logger exists, if it does, return it
        // without further ado.
        Logger childLogger = (Logger) loggerCache.get(name);
        // if we have the child, then let us return it without wasting time
        if (childLogger != null) {
            return childLogger;
        }

        // if the desired logger does not exist, them create all the loggers
        // in between as well (if they don't already exist)
        String childName;
        while (true) {
            int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
            if (h == -1) {
                childName = name;
            } else {
                childName = name.substring(0, h);
            }
            // move i left of the last point
            i = h + 1;
            synchronized (logger) {  // 此logger为 root
                childLogger = logger.getChildByName(childName);
                if (childLogger == null) {
// 调用Logger创建子节点
                    childLogger = logger.createChildByName(childName);
                    loggerCache.put(childName, childLogger);
                    incSize();
                }
            }
            logger = childLogger;
            if (h == -1) {
                return childLogger;
            }
        }
    }


// ch.qos.logback.classic.Logger#createChildByName
    Logger createChildByName(final String childName) {
        int i_index = LoggerNameUtil.getSeparatorIndexOf(childName, this.name.length() + 1);
        if (i_index != -1) {
            throw new IllegalArgumentException("For logger [" + this.name + "] child name [" + childName
                            + " passed as parameter, may not include '.' after index" + (this.name.length() + 1));
        }

        if (childrenList == null) {
            childrenList = new CopyOnWriteArrayList();
        }
        Logger childLogger;
        childLogger = new Logger(childName, this, this.loggerContext);
        childrenList.add(childLogger);
        childLogger.effectiveLevelInt = this.effectiveLevelInt;
        return childLogger;
    }

3.3、level属性继承 和 优先级

1、若自身level为空，则继承父级Logger的level值

ch.qos.logback.classic.Logger#setLevel

    public synchronized void setLevel(Level newLevel) {
        if (level == newLevel) {
            // nothing to do;
            return;
        }
        //  的 level 必填
        if (newLevel == null && isRootLogger()) {
            throw new IllegalArgumentException("The level of the root logger cannot be set to null");
        }

        level = newLevel;
// 若level为空，则使用其父logger的有效level
        if (newLevel == null) {
            effectiveLevelInt = parent.effectiveLevelInt;
            newLevel = parent.getEffectiveLevel();
        } else {
            effectiveLevelInt = newLevel.levelInt;
        }

        if (childrenList != null) {
            int len = childrenList.size();
            for (int i = 0; i < len; i++) {
                Logger child = (Logger) childrenList.get(i);
                // tell child to handle parent levelInt change
                child.handleParentLevelChange(effectiveLevelInt);
            }
        }
        // inform listeners
        loggerContext.fireOnLevelChange(this, newLevel);
    }

3.4、additivity属性

3.4.1、源码分析

1、调用自身的appender进行日志输出

2、若additive=false，则跳出循环，否则调用父logger的appender进行日志输出

ch.qos.logback.classic.Logger#callAppenders

// aai 就是中指定的 AppenderAttachableImpl
    transient private AppenderAttachableImpl aai;

// additive 默认为 true
    transient private boolean additive = true;
    // ............
    
    public void callAppenders(ILoggingEvent event) {
        int writes = 0;
// 1、遍历当前logger的父logger
        for (Logger l = this; l != null; l = l.parent) {
// 2、若当前logger配置了append，则遍历append输出日志信息
            writes += l.appendLoopOnAppenders(event);
// 3、若当前logger的属性additive=false 则跳出循环，不再调用父级
            if (!l.additive) {
                break;
            }
        }
        // No appenders in hierarchy
        if (writes == 0) {
            loggerContext.noAppenderDefinedWarning(this);
        }
    }

    private int appendLoopOnAppenders(ILoggingEvent event) {
// 若当前logger配置了append，则调用其进行日志输出
        if (aai != null) {
            return aai.appendLoopOnAppenders(event);
        } else {
            return 0;
        }
    }

3.4.2、演示

还是上述的例子

1)、只把name=“com.qbhj.logback.controller” 的logger，additivity属性改为”true”

1.1)、结果：打印两遍

###################################### num: 1
21:02:30.800  INFO --- [     http-nio-8080-exec-2] c.qbhj.logback.controller.LogController  : /additivity......
21:02:30.800  INFO --- [     http-nio-8080-exec-2] c.qbhj.logback.controller.LogController  : /additivity......

说明：

，且配置了appender=CONSOLE所以打印日志。其additivity=“true”,调用父级

，且配置了appender=CONSOLE,所以打印日志。其additivity=“false”,跳出循环，结束

2)、只把name=“com.qbhj.logback.controller” 的logger，additivity属性改为”false”, name=”com.qbhj.logback”的logger改为false

2.1)、结果：打印1遍

###################################### num: 1
21:04:10.603  INFO --- [     http-nio-8080-exec-1] c.qbhj.logback.controller.LogController  : /additivity......

说明：

，且配置了appender=CONSOLE所以打印日志。其additivity=“false”，跳出循环，结束

四、日志规范

阿里开发手册(黄山版)中约定如下：

二、异常日志

(三) 日志规约

7.【强制】避免重复打印日志，浪费磁盘空间，务必在日志配置文件中设置 additivity=false

正例：

五、参考资料

阿里开发手册(黄山版).pdf

https://logback.qos.ch/manual/configuration.html#rootElement