logback源码阅读(一)获取ILoggerFactory、Logger

已于 2022-07-29 14:28:11 修改
阅读量1.4k 收藏
点赞数
分类专栏： 源码 文章标签： log4j java apache
于 2022-07-25 11:01:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ethan_199402/article/details/125893575
版权

什么是slf4j

说到logback，必会提及slf4j。slf4j的全称是 : The Simple Logging Facade for Java,是java的一个日志门面，堪称Facade设计模式的最佳代言人! slf4j制定了一套标准接口，从而实现在[日志]这个领域里一统江湖。主要做两件事:

  1. 实现了Logger获取的通用api: LoggreFactory.getLogger()， 该方法基本上确定了获取L ogger的基础套路，约定了实现sIf4j的日志框架需要实现org.slf4j.impl.StaticLoggerBinder,完成与slf4j的集成。
  2. 定义了ILoggerFactory, Logger等系列接口，该接口由具体日志框架实现。

值得强调的是：flf4j是接口,提供API，而 java.util.logging，logback，log4j等才是真正的日志框架

在这里插入图片描述

logback

Logback是由log4j创始人设计的另一个开源日志组件,官方网站： http://logback.qos.ch 是log4j的改良版本，具有更快的实现：
Logback的内核重写了，在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了，初始化内存加载也更小了。

logback 初始化

当一个类使用了@Slf4j注解，lombok是会自动为该类生成一个logger字段的，下面是Slf4j注解的注释

Example:
   @Slf4j
   public class LogExample {
   }
   
will generate:
   public class LogExample {
       private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
   }

我们随便打开一个使用了Slf4j注解的类，查看Structure，可以看到的确生成了对应的logger
在这里插入图片描述
那么，我们就从LoggerFactory.getLogger(this.getClass())这个方法入手，开始一探究竟，本文源码为slf4f-api-1.7.36

getLogger()

public static Logger getLogger(Class<?> clazz) {
        Logger logger = getLogger(clazz.getName());
        if (DETECT_LOGGER_NAME_MISMATCH) {
            Class<?> autoComputedCallingClass = Util.getCallingClass();
            if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
                Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(),
                                autoComputedCallingClass.getName()));
                Util.report("See " + LOGGER_NAME_MISMATCH_URL + " for an explanation");
            }
        }
        return logger;
    }

可以看到，调用getLogger获取logger，如果 clazz 参数与 SLF4J 内部计算的调用者名称不同，则会打印记录器名称不匹配警告，但前提是 slf4j.detectLoggerNameMismatch 系统属性设置为 true。默认情况下，此属性未设置，即使在记录器名称不匹配的情况下也不会打印任何警告。

继续查看getLogger方法

public static Logger getLogger(String name) {
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

每种日志框架都实现了LoggerFactory 这里就是根据集成的日志框架获得对应的factory，接下来看getILoggerFactory方法如何实现

public static ILoggerFactory getILoggerFactory() {
		//没有出初始化则加锁初始化并标记为正在初始化状态
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                    //执行初始化
                    performInitialization();
                }
            }
        }
        switch (INITIALIZATION_STATE) {
        case SUCCESSFUL_INITIALIZATION://初始化成功，返回loggerFactory
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        case NOP_FALLBACK_INITIALIZATION://没有找到StaticLoggerBinder则返回NOPLoggerFactory
            return NOP_FALLBACK_FACTORY;
        case FAILED_INITIALIZATION:
            throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
        case ONGOING_INITIALIZATION:
            // support re-entrant behavior.
            // See also http://jira.qos.ch/browse/SLF4J-97
            //如果 正在初始化,返回替代工厂SubstituteLoggerFactory,日志一般也是委托给NOPLogger
            return SUBST_FACTORY;
        }
        throw new IllegalStateException("Unreachable code");
    }

	static final int UNINITIALIZED = 0;//未初始化
    static final int ONGOING_INITIALIZATION = 1;//正在初始化
    static final int FAILED_INITIALIZATION = 2;//初始化失败,没有实现LoggerFactoryBinder 相关方法，一般是版本过低
    static final int SUCCESSFUL_INITIALIZATION = 3;//初始化成功
    static final int NOP_FALLBACK_INITIALIZATION = 4;//找不到StaticLoggerBinder

我们最关心的应该是performInitialization();

private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }

bind()

private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            // skip check under android, see also
            // http://jira.qos.ch/browse/SLF4J-328
            if (!isAndroid()) {
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
            //打印出实际的日志绑定器 ContextSelectorStaticBinder
            reportActualBinding(staticLoggerBinderPathSet);
        } catch (NoClassDefFoundError ncde) {
            String msg = ncde.getMessage();
            if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
            } else {
                failedBinding(ncde);
                throw ncde;
            }
        } catch (java.lang.NoSuchMethodError nsme) {
            String msg = nsme.getMessage();
            if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                INITIALIZATION_STATE = FAILED_INITIALIZATION;
                Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
                Util.report("Your binding is version 1.5.5 or earlier.");
                Util.report("Upgrade your binding to version 1.6.x.");
            }
            throw nsme;
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        } finally {
            postBindCleanUp();
        }
    }
  1. 非android平台时找到可能的静态日志绑定器的路径集合findPossibleStaticLoggerBinderPathSet()（在classpath查找 org/slf4j/impl/StaticLoggerBinder.class）
  2. 如果日志有多个绑定器，打印到控制台reportMultipleBindingAmbiguity
    如果是android平台，忽略
    依次打印出多个日志绑定器，并给出文档提示
  3. 获得唯一的静态日志绑定器StaticLoggerBinder.getSingleton()
    绑定器内部持有LoggerContext和ContextSelectorStaticBinder
  4. 设置初始化状态为成功
  5. 打印出实际的日志绑定器 ContextSelectorStaticBinder

其中1.2源码比较简单不在展开，重点是第三步

public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }

静态代码块触发init方法

static {
        SINGLETON.init();
    }
    

void init() {
        try {
            try {
            //委托ContextInitializer初始化LoggerContext
                new ContextInitializer(defaultLoggerContext).autoConfig();
            } catch (JoranException je) {
                Util.report("Failed to auto configure default logger context", je);
            }
            // logback-292
            //如果没有配置状态监听器，则打印出警告
            if (!StatusUtil.contextHasStatusListener(defaultLoggerContext)) {
                StatusPrinter.printInCaseOfErrorsOrWarnings(defaultLoggerContext);
            }
            //上下文选择绑定器初始化
            contextSelectorBinder.init(defaultLoggerContext, KEY);
            initialized = true;
        } catch (Exception t) { // see LOGBACK-1159
            Util.report("Failed to instantiate [" + LoggerContext.class.getName() + "]", t);
        }
    }

ContextInitializer.autoConfig()

public void autoConfig() throws JoranException {
         //如果没有，安装状态监听器
         StatusListenerConfigHelper.installIfAsked(loggerContext);
      
        //找到默认的配置文件或者URL,一次按照系统属性logback.configurationFile查找,按照logback-test.xml,logback.groovy,logback.xml得到配置文件
        URL url = findURLOfDefaultConfigurationFile(true);
        if (url != null) {
        //如果找到了，configureByResource(url)
            configureByResource(url);
        } else {//否则，按照spi的方式找到Configurator的实现类，设置上下文，进行配置
            Configurator c = EnvUtil.loadFromServiceLoader(Configurator.class);
            if (c != null) {
                try {
                    c.setContext(loggerContext);
                    c.configure(loggerContext);
                } catch (Exception e) {
                    throw new LogbackException(String.format("Failed to initialize Configurator: %s using ServiceLoader", c != null ? c.getClass()
                                    .getCanonicalName() : "null"), e);
                }
            } else {//如果spi方式拿不到，则使用缺省的BasicConfigurator（里面只配置了一个控制台）设置上下文，进行配置
                BasicConfigurator basicConfigurator = new BasicConfigurator();
                basicConfigurator.setContext(loggerContext);
                basicConfigurator.configure(loggerContext);
            }
        }
    }
  1. 找到默认的配置文件或者URL,依次按照系统属性logback.configurationFile查找,按照logback-test.xml,logback.xml得到配置文件。在这里插入代码片
  2. 如果找到了，configureByResource(url)进行配置
  3. 按照spi的方式找到Configurator的实现类，设置上下文，进行配置
  4. 如果spi方式拿不到，则使用缺省的BasicConfigurator（里面只配置了一个控制台）设置上下文，进行配置
final public static String AUTOCONFIG_FILE = "logback.xml";
final public static String TEST_AUTOCONFIG_FILE = "logback-test.xml";
final public static String CONFIG_FILE_PROPERTY = "logback.configurationFile";

至此，初始化成功，将初始化状态标记为初始化成功，打印日志

versionSanityCheck

得到StaticLoggerBinder的版本，并进行判断是否合适。
LoggerFactory放了允许使用的StaticLoggerBinder的版本，如果不合适，会答应出警告

private final static void versionSanityCheck() {
        try {
            String requested = StaticLoggerBinder.REQUESTED_API_VERSION;

            boolean match = false;
            for (String aAPI_COMPATIBILITY_LIST : API_COMPATIBILITY_LIST) {
                if (requested.startsWith(aAPI_COMPATIBILITY_LIST)) {
                    match = true;
                }
            }
            if (!match) {
                Util.report("The requested version " + requested + " by your slf4j binding is not compatible with "
                                + Arrays.asList(API_COMPATIBILITY_LIST).toString());
                Util.report("See " + VERSION_MISMATCH + " for further details.");
            }
        } catch (java.lang.NoSuchFieldError nsfe) {
            // given our large user base and SLF4J's commitment to backward
            // compatibility, we cannot cry here. Only for implementations
            // which willingly declare a REQUESTED_API_VERSION field do we
            // emit compatibility warnings.
        } catch (Throwable e) {
            // we should never reach here
            Util.report("Unexpected problem occured during version sanity check", e);
        }
    }

getLoggerFactory()

performInitialization方法执行完毕，继续执行StaticLoggerBinder.getSingleton().getLoggerFactory()

public ILoggerFactory getLoggerFactory() {
        if (!initialized) {
            return defaultLoggerContext;
        }

        if (contextSelectorBinder.getContextSelector() == null) {
            throw new IllegalStateException("contextSelector cannot be null. See also " + NULL_CS_URL);
        }
        return contextSelectorBinder.getContextSelector().getLoggerContext();
    }

如果没有初始化过，则返回private LoggerContext defaultLoggerContext = new LoggerContext();
，初始化我们之前刚讲过如下
在这里插入图片描述

最后返回loggerContext，其继承了ILoggerFactory，至此得到ILoggerFactory，接下来是获取logger。

public final Logger getLogger(final String name) {

        if (name == null) {
            throw new IllegalArgumentException("name argument cannot be null");
        }

        // 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;
        }

        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) {
                childLogger = logger.getChildByName(childName);
                if (childLogger == null) {
                    childLogger = logger.createChildByName(childName);
                    loggerCache.put(childName, childLogger);
                    incSize();
                }
            }
            logger = childLogger;
            if (h == -1) {
                return childLogger;
            }
        }
    }
  1. 如果name是root不分大小写，直接返回根logger
  2. 如果logger已经创建过，直接从缓存获取并返回
  3. 如果没有创建过，则创建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>();
        }
        Logger childLogger;
        childLogger = new Logger(childName, this, this.loggerContext);
        childrenList.add(childLogger);
        childLogger.effectiveLevelInt = this.effectiveLevelInt;
        return childLogger;
    }

写的也很明白，创建新的子logger并设置日志生效级别

举个例子：当我们把@slf4f放在一个com.ethan.test.demo的类上，那么上述代码会同时生成的logger为:
com,com.ethan,com.ethan.test,com.ethan.test.demo

Ethan_199402
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@Slf4j vs LoggerFactory.getLogger(): 日志记录方式的对比与选择
wenxuankeji的博客
04-25 1953
@Slf4j vs LoggerFactory.getLogger(): 日志记录方式的对比与选择
logback源代码
04-03
rar包中包括：logback源代码，以及struts2的基础的页面跳转，logback虽然是开源的，但它依赖的jar包找全不也不容易，当然你也可以用Maven去下载是最好的喽。 你可以访问：http://localhost:8080/try2Logback/crud2/login.jsp去访问，在Action中，去根据用户生成用户相关的信息。每个用户都有自己的文件夹。在Tomcat的webapps/Mylog文件夹下。 注意：false如果设置为false，好像是可以提交日志的吞吐量。true默认为false，如果是 true，日志会被安全的写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认是 false。
再看 Logback 源码
CoderLi
10-24 356
三大组件 Logback 构建在三个主要的类上：Logger，Appender 和 Layouts。这三个不同类型的组件一起作用能够让开发者根据消息的类型以及日志的级别来打印日志。 Logger 类作为 logback-classic 模块的一部分。Appender 与 Layouts 接口作为 logback-core 的一部分。作为一个通用的模块，logback-core 没有 logger 的概念。 Appender 与 Layout 有选择的启用或者禁用日志的输出只是 logger 的一部分功能。l
logback源码
admin_dmcn的博客
10-09 257
<?xml version="1.0" encoding="UTF-8"?> <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 --> <!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载...
logback源码浅析
Java_dragon95的博客
04-21 1249
logback源码浅析
Logback入门到实用
04-10 190
Logback入门到实用 概述 LogBack是一个日志框架，它与Log4j可以说是同出一源，都出自Ceki Gülcü之手。（log4j的原型是早前由Ceki Gülcü贡献给Apache基金会的）下载地址：http://logback.qos.ch/download.html ...
springboot、logback源码解读
08-23
springboot、logback源码解读，对logback从初始化到，配置文件加载到日志打印，所有步骤的源码分析
logback-1.1.2源码包
05-28
**logback-1.1.2源码包详解** **一、logback介绍** Logback 是一个用于日志记录的开源框架，由 Ceki Gülcü（也创建了广泛使用的 log4j）开发。它是对 log4j 的升级，旨在提供更高的性能、更灵活的配置以及更好的...
Logback文件获取
12-18
Logback 是一个流行的 Java 日志框架，由 Ceki Gülcü 创建，他是早期日志框架 Log4j 的主要开发者。Logback 致力于提供高效、灵活的日志记录解决方案，适用于各种规模的应用程序。它的核心组件包括三个部分：...
java版ss源码-logback-json-logger:logback-json-logger
06-04
java版s源码logback-json-logger 这是一个用于应用程序记录器的 JSON 编码器。 它也使用 Mapped Diagnostic Contexts () 在每个日志消息中包含适当的上下文信息。 这些是可用于更改日志输出的属性（对于您的...
扩展logback将日志输出到Kafka实例源码
01-23
扩展logback将日志输出到Kafka实例源码，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/79135948
logback+slf4j的JAR包和源码
06-30
只要里面的logback-classic-1.1.7，logback-core-1.1.7，slf4j-api-1.7.21的JAR就可以打印出日志信息，而带有source表示对应的JAR包的源代码。可以要也可以不要
logback jms源码分析加用法小结
03-22
本文将重点探讨Logback如何集成JMS（Java Message Service）进行日志处理，并对相关源码进行深入分析，旨在帮助读者更好地理解和应用这一功能。 一、Logback与JMS的结合 JMS是一种用于在不同应用程序之间传递消息...
Logback源码解析
Snowball
08-09 2288
本文分析源码，Logback版本为1.2.3，SLF4J的版本为1.7.25 1. Logback与SLF4J的关联 1.1 关联类 使用SLF4J作为Log Facade，使用Logback作为具体Log Implementation，配置好logback.xml之后，执行以下代码，就可以使用Logback打印日志。 import org.junit.Test; import o...
Logback源码分析
yangzsirr的博客
05-08 1121
logback源码分析
logback源码分析
u012758488的博客
05-11 180
https://blog.csdn.net/yangzl2008/article/details/81542968 https://www.jianshu.com/p/ebd780b082cb https://www.jianshu.com/p/5616844a5f68 https://blog.csdn.net/yinlongfei_love/article/details/80807321
读logback源码系列文章（六）——ContextInitializer
kyfxbl
09-24 1943
放了一个长假回来啦，继续写本系列博客 这篇博客我们接着上一篇的主题，来介绍一下logback是怎么读取配置文件并初始化整个框架的。还是老规矩，先上总览图 从图中可以看到，logback框架的初始化是由ContextInitializer类来负责完成的，而实际进行配置的是GenericConfigurator类，它调用SaxEventRecorder类来负责读取logback.xml文件，然
读logback源码系列文章（四）——记录日志
kyfxbl
09-24 4057
今天晚上本来想来写一下Logger怎么记录日志，以及Appender组件。不过9点才从丈母娘家回来，又被几个兄弟喊去喝酒，结果回来晚了，所以时间就只够写一篇Logger类的源码分析了。Appender找时间再写 上篇博客介绍了LoggerContext怎么生成Logger，Logger是logback的核心类，也是所有日志框架的核心类。这篇博客详细介绍一下Logger的各字段和方法，重点介绍Lo
读logback源码系列文章（八）——记录日志的实际工作类Encoder
kyfxbl
09-24 1766
本系列的博客从logback怎么对接slf4j开始，逐步介绍了LoggerContext、Logger、ContextInitializer、Appender、Action等核心组件。跟读logback的源码到这个程度，虽然不能说精通，不过至少日常的配置，和简单的自定义扩展都不会有问题了。 这一篇是本系列博客的最后一节，介绍一下实际记录日志的类Encoder。其实继续深入下去，logback还是
logback 源码分析
最新发布
07-24
对于Logback的源码分析，可以从以下几个方面进行深入研究： 1. LoggerContext：Logback的核心组件之一，负责管理Logger、Appender、Filter等实例。可以分析LoggerContext的初始化过程、配置文件加载、上下文维护等。 2. Logger：Logger是Logback的日志记录器，负责日志的打印和传递。可以研究Logger的创建、级别控制、日志传递机制等。 3. Appender：Appender用于将日志输出到不同的目标，比如控制台、文件、数据库等。可以研究各种Appender的实现方式和配置。 4. Layout：Layout用于格式化日志消息。可以分析Layout的实现方式、消息格式化规则等。 5. Filter：Filter用于对日志进行过滤，可以根据一定的条件决定是否记录某条日志。可以研究Filter的实现方式和使用场景。 6. Configuration：Logback的配置文件通常使用XML格式，可以研究配置文件的解析和加载过程，以及如何动态修改配置。 在分析Logback源码时，可以结合官方文档和源码注释进行阅读。同时，建议先了解Logback的基本原理和使用方式，这样能更好地理解源码中的设计和实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值