从源码读log4j配置

ゝ一纸荒年。 2022-12-13 12:47 93阅读 0赞

> **关键词：**log4j

--------------------

日志对于一个项目来说是必不可少的存在。目前日志框架有很多，比如**log4j**、**logback**等。使用这些框架就少不了要配置日志信息，比如日志输出到哪里（控制台或是文件），日志输出的格式等。对于下面的**log4j.properties**配置，你是否疑惑。为什么这么配置，哪儿又对应哪儿。下面我们就来看看log4j的源码，解惑。

log4j.rootLogger=INFO,console
    
    log4j.appender.console=org.apache.log4j.ConsoleAppender
    log4j.appender.console.layout=org.apache.log4j.PatternLayout
    log4j.appender.console.Threshold=INFO
    log4j.appender.console.layout.ConversionPattern=%d - %c -%-4r [%t] %-5p %x - %m%n

--------------------

# **█ 读源码** #

看看log4j是如何根据log4j.properties配置来创建对应的Logger的。入口：**LogManager.getRootLogger()**

无论是org.slf4j.LoggerFactory.getLogger(java.lang.Class<?>)还是com.alibaba.dubbo.common.logger.LoggerFactory.getLogger(java.lang.Class<?>)，当你使用的是log4j日志类时，总能找到LogManager.getRootLogger()这个方法来获取Logger实例。LogManager的全名是：org.apache.log4j.LogManager

以Dubbo的LoggerFactory为例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1][]

LogManager中有个静态代码块，在LogManager初始化类信息时，会执行这边的static代码块，所以在调用LogManager.getRootLogger()方法之前，这里的代码先执行了。和Spring的工作步骤差不多，在调用getBean之前，已经在构造函数中初始化了很多工作。

// LogManager中有个静态方法块。在初始化的时候，会预先调用
    static {
        // 创建一个RootLogger实例，并初始化日志级别是DEBUGE
        // 将创建好的RootLogger实例通过构造器传参构建Hierarchy实例，一般构造器中传参，作用就是初始化属性
        // Hierarchy实现了LoggerRepository接口。这里可以看做创建LoggerRepository的实例。
        Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
        // 构造DefaultRepositorySelector实例，并赋值给repositorySelector
        // 参数是上面的Hierarchy h
        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);
            // 自定义配置文件解析类
            // 默认xml文件是：DOMConfigurator。properties文件是：PropertyConfigurator
            String configuratorClassName = OptionConverter.getSystemProperty("log4j.configuratorClass", (String)null);
            URL url = null;
            if (configurationOptionStr == null) {
                // 加载log4j.xml配置文件。如果你使用的是xml配置方式。这里就会获取到url
                url = Loader.getResource("log4j.xml");
                if (url == null) {
                    // 因为我使用的是properties配置方式。所有走到了这里
                    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 {
                    // 进入下面的方法
                    // url是你配置文件所在的路径URL信息
                    // configuratorClassName==null
                    // getLoggerRepository()就是获取LoggerRepository
                    OptionConverter.selectAndConfigure(url, configuratorClassName, getLoggerRepository());
                } catch (NoClassDefFoundError var6) {
                    LogLog.warn("Error during default initialization", var6);
                }
            } else {
                LogLog.debug("Could not find resource: [" + configurationOptionStr + "].");
            }
        }
    
    }

// log4j会加载类路径下的log4j.xml或log4j.properties文件。这里可以说明log4j的配置文件格式是log4j.xml或log4j.properties的原因。
    // 并且xml配置的优先级要高，即如果同时存在xml和properties配置，则使用xml配置
    url = Loader.getResource("log4j.xml");
    if (url == null) {
        url = Loader.getResource("log4j.properties");
    }

首先进入getLoggerRepository方法看看：

public static LoggerRepository getLoggerRepository() {
        // repositorySelector不为空，因为静态代码块中
        // Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
        // repositorySelector = new DefaultRepositorySelector(h);
        if (repositorySelector == null) {
            repositorySelector = new DefaultRepositorySelector(new NOPLoggerRepository());
            guard = null;
            Exception ex = new IllegalStateException("Class invariant violation");
            String msg = "log4j called after unloading, see http://logging.apache.org/log4j/1.2/faq.html#unload.";
            if (isLikelySafeScenario(ex)) {
                LogLog.debug(msg, ex);
            } else {
                LogLog.error(msg, ex);
            }
        }
        // Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
        // repositorySelector = new DefaultRepositorySelector(h);
        // 这里返回的就是Hierarchy实例 h
        return repositorySelector.getLoggerRepository();
    }

接着回来看，进入OptionConverter.selectAndConfigure方法：

/**
     *  url 配置文件路径
     *  clazz 为null，要是配置了系统变量log4j.configuratorClass，就是配置的值
     *  hierarchy  new Hierarchy(new RootLogger(Level.DEBUG))
     */
    public static void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) {
        Configurator configurator = null;
        String filename = url.getFile();
        // clazz==null，因为我使用的是log4j.properties配置，所以不会进入if
        // 可以看出如果是xml配置会进入这个if语句。
        // DOMConfigurator负责解析xml文件
        if (clazz == null && filename != null && filename.endsWith(".xml")) {
            clazz = "org.apache.log4j.xml.DOMConfigurator";
        }
        // 因为没有进入上面的if，这里的class==null
        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 {
            // PropertyConfigurator负责解析properties配置文件内容
            configurator = new PropertyConfigurator();
        }
        ((Configurator)configurator).doConfigure(url, hierarchy);
    }

进入PropertyConfigurator的doConfigure方法：

public void doConfigure(URL configURL, LoggerRepository hierarchy) {
        // 将配置文件内容封装成Properties对象（键值对形式）
        // 将properties配置中的内容解析封装到Properties中
        Properties props = new Properties();
        ......
                uConn = configURL.openConnection();
                uConn.setUseCaches(false);
                istream = uConn.getInputStream();
                props.load(istream);
        ......
        this.doConfigure(props, hierarchy);
    }

进入doConfigure，这里就是主要的如何根据配置去应用了：

public void doConfigure(Properties properties, LoggerRepository hierarchy) {
        this.repository = hierarchy;
        // 获取配置中的log4j.debug的值，配置true或false。
        // 这个值是配置是否开启log4j内部的日志打印的debug级别
        String value = properties.getProperty("log4j.debug");
        if (value == null) {
            // log4j.configDebug的功能和log4j.debug一样，只是log4j.configDebug已经被废弃。
            // 这里是兼容老版本配置
            value = properties.getProperty("log4j.configDebug");
            if (value != null) {
                LogLog.warn("[log4j.configDebug] is deprecated. Use [log4j.debug] instead.");
            }
        }
    
        if (value != null) {
            // 如果在配置文件中配置了log4j.debug或log4j.configDebug
            // 除非配置的值是false,不区分大小写。否则其他的值返回都是true
            // 这里是设置log4j内部自己打印的日志级别是否允许debug，即LogLog.debug方法
            // 是否可用
            LogLog.setInternalDebugging(OptionConverter.toBoolean(value, true));
        }
    
        String reset = properties.getProperty("log4j.reset");
        if (reset != null && OptionConverter.toBoolean(reset, false)) {
            // 重置log4j的配置。清空以前的配置信息
            hierarchy.resetConfiguration();
        }
        
        // 设置threshold
        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() + "].");
        }
        // 解析log4j.rootLogger配置
        this.configureRootCategory(properties, hierarchy);
        // 解析log4j.loggerFactory配置
        this.configureLoggerFactory(properties);
        // 解析log4j.category、log4j.renderer、log4j.logger、log4j.throwableRenderer的配置
        this.parseCatsAndRenderers(properties, hierarchy);
        LogLog.debug("Finished configuring.");
        this.registry.clear();
    }

进入configureRootCategory方法：

void configureRootCategory(Properties props, LoggerRepository hierarchy) {
        // 获取log4j.rootLogger配置的值
        String effectiveFrefix = "log4j.rootLogger";
        String value = OptionConverter.findAndSubst("log4j.rootLogger", props);
        if (value == null) {
            // 获取不到，再获取log4j.rootCategory配置的值
            // 这里猜想一下：log4j.rootCategory和log4j.rootLogger的作用一样
            value = OptionConverter.findAndSubst("log4j.rootCategory", props);
            effectiveFrefix = "log4j.rootCategory";
        }
    
        if (value == null) {
            LogLog.debug("Could not find root logger information. Is this OK?");
        } else {
            // 获取到的是：new RootLogger(Level.DEBUG)对象
            Logger root = hierarchy.getRootLogger();
            synchronized(root) {
                // 进入这个方法
                this.parseCategory(props, root, effectiveFrefix, "root", value);
            }
        }
    
    }

进入parseCategory：

/**
     * props  解析log4j.properties获取到的键值对
     * logger  new RootLogger(Level.DEBUG)对象
     * optionKey  log4j.rootLogger
     * loggerName  root
     * value   INFO,console（以文章开始我的配置为例。） 
     */
    void parseCategory(Properties props, Logger logger, String optionKey, String loggerName, String value) {
        LogLog.debug("Parsing for [" + loggerName + "] with value=[" + value + "].");
        // 将值按照英文逗号分隔，参考：java.util.StringTokenizer
        StringTokenizer st = new StringTokenizer(value, ",");
        // 如果值不是空字符串，或者不是逗号开头的，比如：,INFO,console
        if (!value.startsWith(",") && !value.equals("")) {
            // 没有元素
            if (!st.hasMoreTokens()) {
                return;
            }
            // 第一个获取日志级别
            // 所以对于配置log4j.rootLogger的配置，第一个值是设置日志的打印级别
            String levelStr = st.nextToken();
            LogLog.debug("Level token is [" + levelStr + "].");
            if (!"inherited".equalsIgnoreCase(levelStr) && !"null".equalsIgnoreCase(levelStr)) {
                // 关于这个日志级别可以配置哪些内容，主要在OptionConverter.toLevel中，后面会看
                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();
        // 接下来就根据设置解析appender了
        // INFO,console，INFO在上面已经处理了，这里处理console
        // 可知console是appender的名称
        while(st.hasMoreTokens()) {
            // 因为在上面已经调用过一次nextToken了，指针移到了下一位，获取到console
            String appenderName = st.nextToken().trim();
            if (appenderName != null && !appenderName.equals(",")) {
                LogLog.debug("Parsing appender named \"" + appenderName + "\".");
                Appender appender = this.parseAppender(props, appenderName);
                if (appender != null) {
                    logger.addAppender(appender);
                }
            }
        }
    
    }

进入parseAppender：

Appender parseAppender(Properties props, String appenderName) {
        // 查看缓存中是否有
        Appender appender = this.registryGet(appenderName);
        if (appender != null) {
            LogLog.debug("Appender \"" + appenderName + "\" was already parsed.");
            return appender;
        } else {
            // 配置前缀：log4j.appender.console
            String prefix = "log4j.appender." + appenderName;
            // 例子中的内容：log4j.appender.console.layout=org.apache.log4j.PatternLayout
            String layoutPrefix = prefix + ".layout";
            // 根据log4j.appender.console配置的值去获取对应的appender实例
            // 例子中配置：log4j.appender.console=org.apache.log4j.ConsoleAppender，获取到的就是ConsoleAppender
            // 可以查看org.apache.log4j.Appender接口的实现类，查看配置值的可选内容
            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);
                // 当前的appender是否实现了OptionHandler接口，ConsoleAppender实现了这个接口
                if (appender instanceof OptionHandler) {
                    if (appender.requiresLayout()) {
                        // 实例化Layout，例子中是：PatternLayout
                        Layout layout = (Layout)OptionConverter.instantiateByKey(props, layoutPrefix, Layout.class, (Object)null);
                        if (layout != null) {
                            appender.setLayout(layout);
                            LogLog.debug("Parsing layout options for \"" + appenderName + "\".");
                            PropertySetter.setProperties(layout, props, layoutPrefix + ".");
                            LogLog.debug("End of parsing for \"" + appenderName + "\".");
                        }
                    }
                    // 处理log4j.appender.console.errorhandler的配置，例子中没有
                    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;
                                }
    
                                Entry entry = (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());
                                }
                            }
                        }
                    }
    
                    PropertySetter.setProperties(appender, props, prefix + ".");
                    LogLog.debug("Parsed \"" + appenderName + "\" options.");
                }
                // 处理log4j.appender.console.filter.开头的配置
                this.parseAppenderFilters(props, appenderName, appender);
                // 加入缓存
                this.registryPut(appender);
                return appender;
            }
        }
    }

configureLoggerFactory和parseCatsAndRenderers的内容就不看了，原理大致相同。我们看OptionConverter.toLevel方法。

public static Level toLevel(String value, Level defaultValue) {
        if (value == null) {
            return defaultValue;
        } else {
            value = value.trim();
            // 十进制35，对应ASCII是#
            int hashIndex = value.indexOf(35);
            if (hashIndex == -1) {
                // 配置形式：log4j.rootLogger=INFO,console，日志级别的设置就是直接设值，INFO,DEBUG等
                return "NULL".equalsIgnoreCase(value) ? null : Level.toLevel(value, defaultValue);
            } else {
                Level result = defaultValue;
                String clazz = value.substring(hashIndex + 1);
                String levelName = value.substring(0, hashIndex);
                if ("NULL".equalsIgnoreCase(levelName)) {
                    return null;
                } else {
                    LogLog.debug("toLevel:class=[" + clazz + "]" + ":pri=[" + levelName + "]");
                    // 使用#分割，使用配置的类的toLevel方法进行转换，比如：log4j.rootLogger=INFO#org.apache.log4j.Level,console
                    // #右边的类要满足：
                    // 1.填写类的全路径名
                    // 2.要继承org.apache.log4j.Level
                    // 3.可重写toLevel(String, Level)方法。第一个参数String就是#左边配置的日志级别，第二个参数Level默认值，如果配置的日志级别不是合法值，用默认值替换
                    // 可参考 org.apache.log4j.helpers.UtilLoggingLevel
                    try {
                        Class customLevel = Loader.loadClass(clazz);
                        Class[] paramTypes = new Class[]{String.class, Level.class};
                        Method toLevelMethod = customLevel.getMethod("toLevel", paramTypes);
                        Object[] params = new Object[]{levelName, defaultValue};
                        Object o = toLevelMethod.invoke((Object)null, params);
                        result = (Level)o;
                    } catch (ClassNotFoundException var11) {
                        LogLog.warn("custom level class [" + clazz + "] not found.");
                    } catch (NoSuchMethodException var12) {
                        LogLog.warn("custom level class [" + clazz + "]" + " does not have a class function toLevel(String, Level)", var12);
                    } catch (InvocationTargetException var13) {
                        if (var13.getTargetException() instanceof InterruptedException || var13.getTargetException() instanceof InterruptedIOException) {
                            Thread.currentThread().interrupt();
                        }
    
                        LogLog.warn("custom level class [" + clazz + "]" + " could not be instantiated", var13);
                    } catch (ClassCastException var14) {
                        LogLog.warn("class [" + clazz + "] is not a subclass of org.apache.log4j.Level", var14);
                    } catch (IllegalAccessException var15) {
                        LogLog.warn("class [" + clazz + "] cannot be instantiated due to access restrictions", var15);
                    } catch (RuntimeException var16) {
                        LogLog.warn("class [" + clazz + "], level [" + levelName + "] conversion failed.", var16);
                    }
    
                    return result;
                }
            }
        }
    }

看到这里，再回头看看文章一开始的log4j.properties中的内容是不是更加清晰了呢？

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: /images/20221123/577e4a341e1747f0a4e66bc25c87b4f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1]: /images/20221123/bba05f53e38d423981c8af81e3c95116.png