Log4j源码解析

这篇具有很好参考价值的文章主要介绍了Log4j源码解析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Log4j源码解析
主要流程
Logger logger = Logger.getLogger(Main.class);

Log4j源码解析,源码解析,log4j,单元测试

1、通过Logger.getLogger(Class clazz) 或 Logger.getLogger(String name)进入。
2、加载LogManager进jvm, 执行静态代码块执行初始化, 创建出RepositorySelector实例及LoggerRepository实例(Hierarchy)。
3、调用OptionConverter.selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy)方法执行配置. (传递Hierarchy)。
4、在OptionConverter中根据存在的配置文件类型创建Configurator实例(这里假设配置文件为log4j.properties), 执行Configurator的doConfigure(URL url, LoggerRepository repository) (传递Hierarchy)。
5、在PropertyConfigurator完成所有组件配置。
6、configureRootCategory(Properties props, LoggerRepository hierarchy) 配置根logger及其appdender等属性。
7、parseCatsAndRenderers(Properties props, LoggerRepository hierarchy) 配置非根的logger及其appdender等属性, 渲染器等。
8、LogManager完成静态代码块后, 通过Hierarchy.getLogger(String name)方法获取出logger对象。

logger.info(“xxx”);

Log4j源码解析,源码解析,log4j,单元测试

1、从main方法出发, 这里示例是调用info()方法. (故后续都是判断info级别)。
2、判断是否满足全局的level级别>=info, 满足则 再判断本logger的level级别是否>=info(本logger没有值则找其父类直至有值)。
3、全局level或本体系的level有其一不满足>=info, 提前结束流程。
4、执行本logger再递归父类logger, 执行其aai.appendLoopOnAppenders()方法 (注: 当前logger执行完会判断additive属性, 为false则不再递归父类, 该点在流程图第20步体现)。
5、遍历当前logger的日志输出器appender, 执行其doAppend()方法
6、进入appender的公共父类AppenderSkeleton的doAppend()方法, 先判断当前appender的日志级别level是否>=info。
7、当前appender日志级别level<info, 结束该appender的执行, 遍历下一个appender。
8、递归执行本appender的过滤器执行链。
9、Filter中进行过滤判定。
10、不满足过滤条件则结束该appender的执行, 遍历下一个appender。
11、执行当前appender的append()方法. (这里假设实现类为RollingFileAppender)。
12、进入appender的公共父类WriterAppender的append()方法, 执行子类RollingFileAppender的subAppend()方法。
13、进入RollingFileAppender的subAppend()方法, 立即调用父类WriterAppender的subAppend()方法, 执行后再执行本类的滚动文件逻辑(该点在流程图第19步体现)。
14、在WriterAppender的subAppend()方法中调用layout执行内容格式化。
15、layout完成输出内容格式化, 返回内容信息。
16、调用QuietWriter将内容写入缓存。
17、在WriterAppender中, 判断属性是否为立即输出, 是则调用QuietWriter写出内容。
18、QuietWriter将内容写出到文件中(若appender为ConsoleAppender则是输出到控制台)。
19、回到RollingFileAppender的subAppend()方法中, 判断是否满足滚动文件逻辑, 是则执行rollOver()。
20、遍历完当前logger后, 判断当前logger的additive属性, 为false则不再递归父类, 提前结束流程。

例:
public class Main {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(Main.class);
        logger.debug("我爱你中国");
    }
}
一、 Logger logger = Logger.getLogger(Main.class);

1.1、跟进到LogManager的static代码块。

    static {
        Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
        repositorySelector = new DefaultRepositorySelector(h);
        String override = OptionConverter.getSystemProperty("log4j.defaultInitOverride", (String)null);
        if (override != null && !"false".equalsIgnoreCase(override)) {
            LogLog.debug("Default initialization of overridden by log4j.defaultInitOverrideproperty.");
        } else {
            String configurationOptionStr = OptionConverter.getSystemProperty("log4j.configuration", (String)null);
            String configuratorClassName = OptionConverter.getSystemProperty("log4j.configuratorClass", (String)null);
            URL url = null;
            if (configurationOptionStr == null) {
                url = Loader.getResource("log4j.xml");
                if (url == null) {
                    url = Loader.getResource("log4j.properties");
                }
            } else {
                try {
                    url = new URL(configurationOptionStr);
                } catch (MalformedURLException var7) {
                    url = Loader.getResource(configurationOptionStr);
                }
            }

            if (url != null) {
                LogLog.debug("Using URL [" + url + "] for automatic log4j configuration.");

                try {
                    OptionConverter.selectAndConfigure(url, configuratorClassName, getLoggerRepository());
                } catch (NoClassDefFoundError var6) {
                    LogLog.warn("Error during default initialization", var6);
                }
            } else {
                LogLog.debug("Could not find resource: [" + configurationOptionStr + "].");
            }
        }

    }

1.2、

1.2.1、初始化repositorySelector, 并设置选择器的LoggerRepository为Hierarchy, 创建根logger。
1.2.2、先查找log4j.xml, 没有再查找log4j.properties文件。
1.2.3、读取配置, 完成logger初始化 OptionConverter.selectAndConfigure(…);

1.3、跟进OptionConverter.selectAndConfigure(url, configuratorClassName, getLoggerRepository());

public static void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) {
        Configurator configurator = null;
        String filename = url.getFile();
        if (clazz == null && filename != null && filename.endsWith(".xml")) {
            clazz = "org.apache.log4j.xml.DOMConfigurator";
        }

        if (clazz != null) {
            LogLog.debug("Preferred configurator class: " + clazz);
            configurator = (Configurator)instantiateByClassName(clazz, Configurator.class, (Object)null);
            if (configurator == null) {
                LogLog.error("Could not instantiate configurator [" + clazz + "].");
                return;
            }
        } else {
            configurator = new PropertyConfigurator();
        }

        ((Configurator)configurator).doConfigure(url, hierarchy);
    }

1.3.1、配置文件为log4j.xml, 则使用 DOMConfigurator来解析。
1.3.2、配置文件为log4j.properties, 则使用PropertyConfigurator来解析。

1.4、继续跟进((Configurator)configurator).doConfigure(url, hierarchy);到PropertyConfigurator类的doConfigure()方法。

    public void doConfigure(Properties properties, LoggerRepository hierarchy) {
        this.repository = hierarchy;
        String value = properties.getProperty("log4j.debug");
        if (value == null) {
            value = properties.getProperty("log4j.configDebug");
            if (value != null) {
                LogLog.warn("[log4j.configDebug] is deprecated. Use [log4j.debug] instead.");
            }
        }

        if (value != null) {
            LogLog.setInternalDebugging(OptionConverter.toBoolean(value, true));
        }

        String reset = properties.getProperty("log4j.reset");
        if (reset != null && OptionConverter.toBoolean(reset, false)) {
            hierarchy.resetConfiguration();
        }

        String thresholdStr = OptionConverter.findAndSubst("log4j.threshold", properties);
        if (thresholdStr != null) {
            hierarchy.setThreshold(OptionConverter.toLevel(thresholdStr, Level.ALL));
            LogLog.debug("Hierarchy threshold set to [" + hierarchy.getThreshold() + "].");
        }

        this.configureRootCategory(properties, hierarchy);
        this.configureLoggerFactory(properties);
        this.parseCatsAndRenderers(properties, hierarchy);
        LogLog.debug("Finished configuring.");
        this.registry.clear();
    }

1.4.1、核心代码: 配置根logger及其appender。

 this.configureRootCategory(properties, hierarchy);
 void parseCategory(Properties props, Logger logger, String optionKey, String loggerName, String value) {
        LogLog.debug("Parsing for [" + loggerName + "] with value=[" + value + "].");
        StringTokenizer st = new StringTokenizer(value, ",");
        if (!value.startsWith(",") && !value.equals("")) {
            if (!st.hasMoreTokens()) {
                return;
            }

            String levelStr = st.nextToken();
            LogLog.debug("Level token is [" + levelStr + "].");
            if (!"inherited".equalsIgnoreCase(levelStr) && !"null".equalsIgnoreCase(levelStr)) {
                logger.setLevel(OptionConverter.toLevel(levelStr, Level.DEBUG));
            } else if (loggerName.equals("root")) {
                LogLog.warn("The root logger cannot be set to null.");
            } else {
                logger.setLevel((Level)null);
            }

            LogLog.debug("Category " + loggerName + " set to " + logger.getLevel());
        }

        logger.removeAllAppenders();

        //遍历log4j.rootLogger中的appenderName
        while(st.hasMoreTokens()) {
            String appenderName = st.nextToken().trim();
            if (appenderName != null && !appenderName.equals(",")) {
                LogLog.debug("Parsing appender named \"" + appenderName + "\".");
                //核心代码:根据appenderName解析出appender
                Appender appender = this.parseAppender(props, appenderName);
                if (appender != null) {
                //将appender加入到logger的AppenderAttachableImpl的appenderList中
                    logger.addAppender(appender);
                }
            }
        }

    }

1.4.1.1、跟进logger.addAppender(appender);最终调用AppenderAttachableImpl类的addAppender方法。

  public void addAppender(Appender newAppender) {
        if (newAppender != null) {
            if (this.appenderList == null) {
                this.appenderList = new Vector(1);
            }

            if (!this.appenderList.contains(newAppender)) {
                this.appenderList.addElement(newAppender);
            }

        }
    }

1.4.1.2、跟进Appender appender = this.parseAppender(props, appenderName);

Appender parseAppender(Properties props, String appenderName) {
        //根据appenderName获取registry缓存中的appender, 若存在则直接放回
        Appender appender = this.registryGet(appenderName);
        if (appender != null) {
            LogLog.debug("Appender \"" + appenderName + "\" was already parsed.");
            return appender;
        } else {
            String prefix = "log4j.appender." + appenderName;
            //.layout在配置文件中是小写的
            String layoutPrefix = prefix + ".layout";
            appender = (Appender)OptionConverter.instantiateByKey(props, prefix, Appender.class, (Object)null);
            if (appender == null) {
                LogLog.error("Could not instantiate appender named \"" + appenderName + "\".");
                return null;
            } else {
                appender.setName(appenderName);
                if (appender instanceof OptionHandler) {
                    if (appender.requiresLayout()) {
                        Layout layout = (Layout)OptionConverter.instantiateByKey(props, layoutPrefix, Layout.class, (Object)null);
                        if (layout != null) {
                            appender.setLayout(layout);
                            LogLog.debug("Parsing layout options for \"" + appenderName + "\".");
                            //设置layout属性
                            PropertySetter.setProperties(layout, props, layoutPrefix + ".");
                            LogLog.debug("End of parsing for \"" + appenderName + "\".");
                        }
                    }
                    //初始化异常处理器
                    String errorHandlerPrefix = prefix + ".errorhandler";
                    String errorHandlerClass = OptionConverter.findAndSubst(errorHandlerPrefix, props);
                    if (errorHandlerClass != null) {
                        ErrorHandler eh = (ErrorHandler)OptionConverter.instantiateByKey(props, errorHandlerPrefix, ErrorHandler.class, (Object)null);
                        if (eh != null) {
                            appender.setErrorHandler(eh);
                            LogLog.debug("Parsing errorhandler options for \"" + appenderName + "\".");
                            this.parseErrorHandler(eh, errorHandlerPrefix, props, this.repository);
                            Properties edited = new Properties();
                            String[] keys = new String[]{errorHandlerPrefix + "." + "root-ref", errorHandlerPrefix + "." + "logger-ref", errorHandlerPrefix + "." + "appender-ref"};
                            Iterator iter = props.entrySet().iterator();

                            while(true) {
                                if (!iter.hasNext()) {
                                    PropertySetter.setProperties(eh, edited, errorHandlerPrefix + ".");
                                    LogLog.debug("End of errorhandler parsing for \"" + appenderName + "\".");
                                    break;
                                }

                                Map.Entry entry = (Map.Entry)iter.next();

                                int i;
                                for(i = 0; i < keys.length && !keys[i].equals(entry.getKey()); ++i) {
                                }

                                if (i == keys.length) {
                                    edited.put(entry.getKey(), entry.getValue());
                                }
                            }
                        }
                    }
                    //反射设置appender的其他属性
                    PropertySetter.setProperties(appender, props, prefix + ".");
                    LogLog.debug("Parsed \"" + appenderName + "\" options.");
                }

                this.parseAppenderFilters(props, appenderName, appender);
                //加入registry缓存中
                this.registryPut(appender);
                return appender;
            }
        }
    }

1.4.2、跟进this.configureLoggerFactory(properties);

   protected void configureLoggerFactory(Properties props) {
        String factoryClassName = OptionConverter.findAndSubst("log4j.loggerFactory", props);
        if (factoryClassName != null) {
            LogLog.debug("Setting category factory to [" + factoryClassName + "].");
            this.loggerFactory = (LoggerFactory)OptionConverter.instantiateByClassName(factoryClassName, LoggerFactory.class, this.loggerFactory);
            PropertySetter.setProperties(this.loggerFactory, props, "log4j.factory.");
        }

    }

1.4.2.1、获取配置文件loggerFactory全限定名, 创建loggerFactory实例。
1.4.2.2、反射设置loggerFactory的属性,注: 不配置时, loggerFactory使用默认值, 为DefaultCategoryFactory实例对象. loggerFactory用于创建自定义的logger对象。

1.4.3、跟进this.parseCatsAndRenderers(properties, hierarchy);主要是父子logger的绑定和设置logger的additive属性。文章来源地址https://www.toymoban.com/news/detail-608519.html

    protected void parseCatsAndRenderers(Properties props, LoggerRepository hierarchy) {
        Enumeration enumeration = props.propertyNames();

        while(true) {
            while(enumeration.hasMoreElements()) {
                String key = (String)enumeration.nextElement();
                String loggerName;
                String value;
                if (!key.startsWith("log4j.category.") && !key.startsWith("log4j.logger.")) {
                    if (key.startsWith("log4j.renderer.")) {
                        loggerName = key.substring("log4j.renderer.".length());
                        value = OptionConverter.findAndSubst(key, props);
                        if (hierarchy instanceof RendererSupport) {
                            RendererMap.addRenderer((RendererSupport)hierarchy, loggerName, value);
                        }
                    } else if (key.equals("log4j.throwableRenderer") && hierarchy instanceof ThrowableRendererSupport) {
                        ThrowableRenderer tr = (ThrowableRenderer)OptionConverter.instantiateByKey(props, "log4j.throwableRenderer", ThrowableRenderer.class, (Object)null);
                        if (tr == null) {
                            LogLog.error("Could not instantiate throwableRenderer.");
                        } else {
                            PropertySetter setter = new PropertySetter(tr);
                            setter.setProperties(props, "log4j.throwableRenderer.");
                            ((ThrowableRendererSupport)hierarchy).setThrowableRenderer(tr);
                        }
                    }
                } else {
                    loggerName = null;
                    if (key.startsWith("log4j.category.")) {
                        loggerName = key.substring("log4j.category.".length());
                    } else if (key.startsWith("log4j.logger.")) {
                        loggerName = key.substring("log4j.logger.".length());
                    }

                    value = OptionConverter.findAndSubst(key, props);
                    //核心代码: 创建出自定义logger对象, 绑定其与其他logger的关系
                    Logger logger = hierarchy.getLogger(loggerName, this.loggerFactory);
                    synchronized(logger) {
                        this.parseCategory(props, logger, key, loggerName, value);
                        this.parseAdditivityForLogger(props, logger, loggerName);
                    }
                }
            }

            return;
        }
    }
二、logger.info(“我爱你中国”);

到了这里,关于Log4j源码解析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【日志加载 log4j】

    2.编写配置 3.获取日志对象 4.1 Loggers 记录器 4.2 Appenders 输出源 4.3 Layouts 布局 5. 配置文件 log4j.properties

    2024年02月11日
    浏览(91)
  • log4j漏洞详解

    log4j全名就是(log for java),就是apache的一个开源的日志记录组件 ,它在Java项目中使用的比较广泛。 使用方法:                 1.pom引入依赖                 2.获取logger实例                 3.logger.info() debug() error() warn()... 优点:功能丰富,易于集成

    2024年02月16日
    浏览(43)
  • log4j警告之log4j:WARN No appenders could be found for logger

    目录 1. 警告信息  2. 错误解读  3.解决办法   错误输出信息: log4j:WARN No appenders could be found for logger (org.apache.flink.api.java.utils.PlanGenerator). log4j:WARN Please initialize the log4j system properly. log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info. 如果找不到默认配置文件log4j

    2024年02月14日
    浏览(55)
  • 单元测试报错解决java.lang.NoClassDefFoundError: org/apache/logging/log4j/util/ReflectionUtil

    原因是新版本的log4j-core包中不包含org/apache/logging/log4j/util/ReflectionUtil这个类,在2.2版本后这个类被迁移到log4j-jcl包中。 引入新的包即可 maven引入 gradle引入 即可解决

    2024年02月16日
    浏览(46)
  • ctfshow-Log4j复现-log4j复现

    1、买VPS,打开mobax进行ssh连接,开两个终端 一个终端开启监听 另一个终端进入JNDIExploit-1.2-SNAPSHOT.jar所在的目录jndiexploit执行下面命令 生成payload 构造payload 输入进去之后看结果 反弹shell成功 结束

    2024年02月12日
    浏览(53)
  • log4j日志框架的使用

    log4j的配置文件可以理解成有2部分 1根日志记录器  2 各appender(输出源)配置 入口 loggerManager的静态代码块 在loggerManager的静态代码块中,完成对配置文件的读取和解析 然后组装成框架的Logger对象、appender对象完成初始化操作 当调用logger.info打印日志时,和logback的流程基本一样

    2024年02月04日
    浏览(61)
  • 用Log4j 2记录日志

    下面代码示例的maven工程中的pom.xml文件中需要增加对Log4j 2的依赖: 配置说明参考文档 https://logging.apache.org/log4j/2.x/manual/configuration.html 配置文件中pattern的详细说明 例如,下面配置文件片段中用到了pattern: pattern的详细说明请参考: https://logging.apache.org/log4j/2.x/manual/layouts.ht

    2024年02月14日
    浏览(97)
  • Log4j远程代码执行漏洞

    简介 漏洞描述 Apache Log4j 是 Apache 的一个开源项目,Apache log4j-2 是 Log4j 的升级,我们可以控制日志信息输送的目的地为控制台、文件、GUI组件等,通过定义每一条日志信息的级别,能够更加细致地控制日志的生成过程。 Log4j-2中存在JNDI注入漏洞,当程序将用户输入的数据日志

    2024年02月11日
    浏览(67)
  • log4j JNDI注入漏洞

    目录 log4j JNDI注入漏洞 一、LDAP介绍 二、JDBC介绍 三、JNDI介绍 四、JNDI命名引用 五、log4j JNDI注入漏洞 ​LDAP是一种协议,LDAP 的全称是 Lightweight Directory Access Protocol,轻量目录访问协议。 ​JDBC是一种规范,JDBC的全称是Java数据库连接(Java Database connect),它是一套用于执行SQL语句

    2024年02月01日
    浏览(45)
  • Java日志框架JUL、Log4j、logback、log4j2使用

    随着软件系统的发展系统业务越来越多、逻辑越来越复杂、代码量越来越多,伴随着容易出现的bug也会越来越多,不论是开发测试阶段还是生产阶段都需要将这些错误及时的捕捉记录下来,方便解决这些问题,否则针对出现的异常无从下手;此时就需要一些日志框架来完成这

    2024年02月15日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包