5.3、深入日志配置文件

配置文件详解(含源码)*

之前介绍了JDK默认的配置文件logging.properties，其中内容其实并不完整，本部分来完善相关的日志配置文件，并再去窥探源码看看在程序中是如何读取到配置文件中的配置信息的：

# 1、handlers集合介绍
# 1.1、handlers(无层级关系默认为RootLogger的handlers)：是一个集合可设置多个handler
handlers = java.util.logging.ConsoleHandler,java.util.logging.FileHandler
# 默认为RootLogger的日志等级
.level= ALL
# 1.2、该handlers(包含层级关系，若程序中logger的name为xyz.changlu则默认为其添加handlers)：
#                          相当于对获取的logger实例添加自定义handlers集合
xyz.changlu.handlers = java.util.logging.FileHandler
# name为xyz.changlu的logger的日志等级
xyz.changlu.level = ALL
# name为xyz.changlu的logger忽略父日志设置
xyz.changlu.useParentHandlers = false

# 2、处理器设置
# 2.1、ConsoleHandler(控制台处理器)：设置等级为ALL
java.util.logging.ConsoleHandler.level = ALL
# 设置输出日志格式使用SimpleFormatter
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 设置指定的编码格式
java.util.logging.ConsoleHandler.encoding = UTF-8
# 2.2、FileHandler(文件处理器)：设置日志等级为ALL
java.util.logging.FileHandler.level = ALL
# 设置输出日志文件路径：%h表示家目录  %u与下面count有关(范围为[0,count))
java.util.logging.FileHandler.pattern = %h/logs/java%u.log
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 1
# 设置输出日志格式使用SimpleFormatter
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 输出的日志内容是否追加到文件
java.util.logging.FileHandler.append = true

# 3、指定转换器的日志格式
# 3.1、指定SimpleFormatter的转换形式 该format输入内容为 如WARNING: warning message [Tue Mar 22 13:11:31 PDT 2011]  对比以前少了指定调用方法
java.util.logging.SimpleFormatter.format = "%4$s: %5$s [%1$tc]%n"

# 设置name=com.xyz.foo的logger实例的日志等级(可省略不看)
com.xyz.foo.level = SEVERE

• 对于RootLogger的日志等级、指定handlers集合以及为自定义logger设置handlers以及日志等级；
• 针对于不同处理器进行设置日志等级，其中FileHandler设置较多，包含日志等级、路径、文件大小、日志文件限制个数、转换各时期、是否追加。
• 对于SimpleFormatter也可进行转换格式设置，设置formatter参数。

该配置文件又补充了不少内容，那么补充的依据是在哪里呢？我们去源码中一探究竟：

首先看下ConsoleHandler类：其在初始化构造器时就进行了一系列的操作

public class ConsoleHandler extends StreamHandler {
	//1、无参构造
	public ConsoleHandler() {
        sealed = false;
        configure();//进行配置 去到2
        setOutputStream(System.err);
        sealed = true;
    }
    
    //2、进行配置操作
    private void configure() {
        LogManager manager = LogManager.getLogManager();//在此之间该LogManager的单例已经加载了自定义配置文件或官方提供的配置文件
        //cname就是获取本身的类名，为java.util.logging.ConsoleHandler
        String cname = getClass().getName();
		//重要！！！！
        //setLevel()中的方法意思是，首先会去该LogManager实例的getProperty()方法获取对应的值(实际上就是使用properties实例获取键值对中的值)，若是没有获取到就使用第二个参数默认设置为INFO
        setLevel(manager.getLevelProperty(cname +".level", Level.INFO));
        //针对于Filter若是从properteis中找不到对应的键值对，则默认设置filter为null
        setFilter(manager.getFilterProperty(cname +".filter", null));
        //若是找不到键值对，则默认设置转换器为SimpleFormatter
        setFormatter(manager.getFormatterProperty(cname +".formatter", new SimpleFormatter()));
        try {
            //同理，之类若是没有设置编码格式，则会设置为null
            setEncoding(manager.getStringProperty(cname +".encoding", null));
        } catch (Exception ex) {
            try {
                setEncoding(null);
            } catch (Exception ex2) {
                // doing a setEncoding with null should always work.
                // assert false;
            }
        }
    }
}

• 实际上就是配置文件中对应的java.util.logging.ConsoleHandler.xxx的值，所以我们要记住了当我们进行自定义配置文件之后若是对对应handler进行了设置，那么在之后初始化handler实例也会受到影响！！！

相对于FileHandler也同样如此，我直接放相应代码即可：

//同样无参构造中调用了configure()方法
private void configure()() {
    LogManager manager = LogManager.getLogManager();

    //cname = java.util.logging.FileHandler
    String cname = getClass().getName();

    //若是LogManager实例中的properties实例若是读取不到指定键值对java.util.logging.FileHandler.pattern，默认路径为%h/java%u.log
    pattern = manager.getStringProperty(cname + ".pattern", "%h/java%u.log");
    //若是读取不到java.util.logging.FileHandler.limit，默认为0
    limit = manager.getIntProperty(cname + ".limit", 0);
    if (limit < 0) {
        limit = 0;
    }
    //读取不到默认为1 (对应%u)
    count = manager.getIntProperty(cname + ".count", 1);
    if (count <= 0) {
        count = 1;
    }
    //append是是否追加的意思，默认若是没有配置文件为false，每次向文件写日志时就会进行覆盖，所以一般会设置为true
    append = manager.getBooleanProperty(cname + ".append", false);
    //对于FileHandler，若是没有自定义配置，会设置日志等级为ALL
    setLevel(manager.getLevelProperty(cname + ".level", Level.ALL));
    //对于过滤器，无自定义配置时默认为null
    setFilter(manager.getFilterProperty(cname + ".filter", null));
    //对于转换器，无自定义配置时默认为XMLFormatter(就是以XML形式保存，一般不这样)
    setFormatter(manager.getFormatterProperty(cname + ".formatter", new XMLFormatter()));
    try {
        //对于编码，无自定义配置时默认为null
        setEncoding(manager.getStringProperty(cname +".encoding", null));
    } catch (Exception ex) {
        try {
            setEncoding(null);
        } catch (Exception ex2) {
        }
    }
}

• ok，可以看到FileHandler与ConsoleHandler的默认配置还有有差别的。对于日志等级FileHandler为ALL，而console为INFO；对于转换器formatter，FileHandler默认设置为XMLFormatter，console默认设置为SimpleFormatter。

最后看下转换器SimpleFormatter类：

public class SimpleFormatter extends Formatter {
	//这里是调用一个方法获取的，和之前的有些不一样，我们深入看一下  见1
	private static final String format = LoggingSupport.getSimpleFormat()
}

//看一下LoggingSupport，粗略看下即可
public class LoggingSupport {
    
    //1、LoggingSupport的静态方法
    public static String getSimpleFormat() {
        return getSimpleFormat(true);//见2
    }
    
    //2、注意这个方法中的操作与之前的就大致相同了！！！
    static String getSimpleFormat(boolean var0) {
        String var1 = (String)AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                //这里是尝试获取System类中props是否有该键值对，默认是没有的，返回null
                return System.getProperty("java.util.logging.SimpleFormatter.format");
            }
        });
        //注意这里：若是参数var0为true&系统变量中没有读取到var1&代理类不为null(该代理类是static实例)
        //实际上这里调用代理类的getProperty()方法就是调用的LogManager.getLogManager().getProperty(key);
        //其实也就是之前LogManager读取的配置文件流！！！若是我们自定义了就会取到对应的值，没有的话返回null
        if (var0 && proxy != null && var1 == null) {
            var1 = proxy.getProperty("java.util.logging.SimpleFormatter.format");
        }

        //若var1不为null，表示从自定义配置文件中读取到了
        if (var1 != null) {
            try {
                //格式化时会加上调用该方法的日期
                String.format(var1, new Date(), "", "", "", "", "");
            } catch (IllegalArgumentException var3) {
                var1 = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%6$s%n";
            }
        } else {
            //自定义配置文件没有配置时采用该格式
            var1 = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%6$s%n";
        }
        return var1;
    }
}

我们这边再看下proxy实例是怎么获取到的，以及调用的getProperty()到底是什么：

最后对于该format的设置可以见源码中的注释，有是包含详细例子：

• 三个方框里的是使用对应format打印出的例子。
• 三个示例贴在这里：%4$s: %5$s [%1$tc]%n、%1$tc %2$s%n%4$s: %5$s%6$s%n、%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s%n%4$s: %5$s%n。其中符号含义可见源码或者api文档。

小案例

要求：在自定义配置文件中指定name=xyz.changlu的logger实例(日志等级为ALL)包含一个FileHandler(限制大小为50000字节，文件数1个，路径指定D盘的los目录中，日志等级为ALL)，该FileHandler对应一个SimpleFormatter(打印两行信息的格式)，并且支持追加。

答：自定义配置文件如下：

# 指定name为xyz.changlu的handlers集合中添加FileHandler
xyz.changlu.handlers = java.util.logging.FileHandler
# 该logger日志等级为ALL
xyz.changlu.level = ALL
# 表示不使用父元素的handlers集合(这里可不加)
xyz.changlu.useParentHandlers = false

# FileHandler的日志等级为ALL、路径、限制大小、数量、指定转换器、以及是否追加
java.util.logging.FileHandler.level = ALL
java.util.logging.FileHandler.pattern = D:/logs/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
java.util.logging.FileHandler.append = true

# SimpleFormatter中转换格式为堆栈方法
java.util.logging.SimpleFormatter.format = "%1$tc %2$s%n%4$s: %5$s%6$s%n"

• 这里我们没有指定rootlogger的handler，那么初始时自动创建的对应rootlogger的handlers则不会存在。

注意点：logs目录我们应当提前创建好，否则会报错。(若logs目录没有，则会出现找不到文件的异常)

我们来验证一下结果：

@Test
public void test02() throws IOException {
    //读取配置文件输入流
    InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("logging.properties");
    //让LogManager来读取输入流
    LogManager.getLogManager().readConfiguration(is);
    
    //前两步骤做好之后再进行日志测试
    Logger logger = Logger.getLogger("xyz.changlu");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

• 屏幕前确实没有输出任何信息。

• 成功打印到指定文件目录下的对应文件中。

5.4、深入源码(日志执行流程,后)*

之前5.1看的源码是关于配置文件相关的，这里的话来看一看日志执行的流程：

//getlogger()方法读取了配置文件(前面5.1部分看的源码)
Logger logger = Logger.getLogger("xyz.changlu");
//本部分来看一下logger实例调用servere()方法中的执行过程
logger.severe("severe");

接下来跟着一起看下去吧：

public class Logger {
    
    //1、该方法实际就是调用的log()方法，其第一个参数就是指定日志等级，很明显这里就是封装了一下变得更简洁
    public void severe(String msg) {
        log(Level.SEVERE, msg);//见2
    }
    
    //2、传入日志等级，以及日志要打印的msg参数
    public void log(Level level, String msg) {
        //重要①(比较自身logger实例的level)，若是返回false，则该日志直接结束不进行下去
        if (!isLoggable(level)) {//见3
            return;
        }
        //将日志等级以及msg日志描述参数封装到LogRecord实例中
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);//见4
    }
    
    //3、对日志等级进行比较
    public boolean isLoggable(Level level) {
        //实例本身日志等级比当前要打印的日志等级大或者实例本身日志等级为最大情况下返回false
      if (level.intValue() < levelValue || levelValue == offValue) {//offValue的value为Integer.MAX_VALUE
            return false;
      }
      return true;
    }
    
    //4、传入封装好日志等级以及msg的lr
    private void doLog(LogRecord lr) {
        lr.setLoggerName(name);
        final LoggerBundle lb = getEffectiveLoggerBundle();
        final ResourceBundle  bundle = lb.userBundle;
        final String ebname = lb.resourceBundleName;
        if (ebname != null && bundle != null) {
            lr.setResourceBundleName(ebname);
            lr.setResourceBundle(bundle);
        }
        //上面先省略，继续看该方法
        log(lr);//见5
    }
    
    //5、该方法是执行过程中很重要的一部分
    public void log(LogRecord record) {
        //这里再次比较logger实例的日志等级以及本次日志打印的日志等级(有疑惑之前不是已经比较过了嘛)
        if (!isLoggable(record.getLevel())) {
            return;
        }
        //重要②，这里filter是本logger实例的filter过滤器
        Filter theFilter = filter;
        //重要②，若过滤器为不为null同时该过滤器的方法执行返回为false时直接结束方法
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }
        
        //获取本身logger实例
        Logger logger = this;
        //接着开始执行logger实例中的handlers了
        while (logger != null) {
            //在Logger(String name)中设置isSystemLogger为true了，将原本使用List存储的handlers转为一个数组形式
            final Handler[] loggerHandlers = isSystemLogger
                ? logger.accessCheckedHandlers()
                : logger.getHandlers();
			//重要③：遍历handlers数组
            for (Handler handler : loggerHandlers) {
                //重要④：这一步实际上就是使用handler进行输出日志msg信息
                handler.publish(record);//去6
            }

            //若是useParentHandlers为true将该布尔值给一个临时变量
            final boolean useParentHdls = isSystemLogger
                ? logger.useParentHandlers
                : logger.getUseParentHandlers();
			//若是useParentHdls为false(表示不获取其父handler)，那么就不会往下执行，整个log()方法结束
            if (!useParentHdls) {
                break;
            }
			//获取到上级logger(若是没有定义多个有层级关系的logger，则为rootlogger)
            //重新执行比对一遍logger的handlers集合中的日志等级及过滤器
            logger = isSystemLogger ? logger.parent : logger.getParent();
        }
    }
    
}

//假定当前的handler为ConsoleHandler(几个handler执行过程大致相同)
public class ConsoleHandler extends StreamHandler {
    
    //6、输出方法
    @Override
    public void publish(LogRecord record) {
        //调用的是父类StreamHandler的publish()方法
        super.publish(record);//去7
        //刷新字符流
        flush();
    }
}

//Handler的父类StreamHandler
public class StreamHandler extends Handler {
    
    //7、StreamHandler的publish()方法
    @Override
    public synchronized void publish(LogRecord record) {
        //重要⑤：比对指定handler的日志等级与logger实例的日志等级
        if (!isLoggable(record)) {//去8
            return;
        }
        //若是前面都顺利通过来到这里
        String msg;
        try {
            //使用logger实例指定的转换器进行格式转换
            msg = getFormatter().format(record);
        } catch (Exception ex) {
            reportError(null, ex, ErrorManager.FORMAT_FAILURE);
            return;
        }

        try {
            if (!doneHeader) {
                writer.write(getFormatter().getHead(this));
                doneHeader = true;
            }
            //最终打印出日志信息(根据handler决定去处)
            writer.write(msg);
        } catch (Exception ex) {
            reportError(null, ex, ErrorManager.WRITE_FAILURE);
        }
    }
    
    //8、这里有判断record与输出流是否为null
    @Override
    public boolean isLoggable(LogRecord record) {
        if (writer == null || record == null) {
            return false;
        }
        return super.isLoggable(record);//去9 (Handler类中的方法)
    }
}

//StreamHandler的父类Handler
public abstract class Handler {
    
    private static final int offValue = Level.OFF.intValue();
    
    //9、这里才是真正比较handler的日志等级与logger实例的日志等级
    public boolean isLoggable(LogRecord record) {
        //levelValue默认为ALL，若是读取官方配置文件按配置文件的日志等级为INFO(这里默认读取官方配置为文件)
        final int levelValue = getLevel().intValue();
        //若是logger实例的日志等级为小于INFO或当前levelValue为Integer.MAX_VALUE，则结束方法回退到7
        if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
            return false;
        }
        //若是日志等级通过，在调用执行handler的filter过滤器进行比对
        final Filter filter = getFilter();
        if (filter == null) {
            //若是无过滤器直接通过
            return true;
        }
        //指定filter方法返回filter的结果
        return filter.isLoggable(record);
    }

• 其实主要关键的看第3、5、7、9方法，最主要的是第5方法(核心调用)

这部分源码的执行过程以及之前读取配置文件放在下个部分统一总结，好好理清一下思路。

六、总结

五章节前后源码总结*

读取配置文件部分总结

当调用Logger.getLogger()获取logger实例时，该方法中间进行了读取配置文件的操作：

1. 读取自定义配置类。首先会去看System类中是否包含java.util.logging.config.class对应键值对的值，若是有会对该配置类进行实例化，直接结束配置读取。
2. 读取自定义配置文件。会去看有没有java.util.logging.config.file对应的配置文件路径，有的话赋值到String fname中。
3. 读取官方默认的配置文件(/jre/lib/logging.properties)。若是fame没有说明没有对应的配置文件路径，就会默认去找到java配置的路径，获取到完整路径同样赋值到String fname中。
   • 无论执行2或3步骤都是得到的一个fname全路径地址，使用FileInputStream将对应配置文件转为输入流，再统一使用LogManager中的properties实例的load()方法加载该输入流。

若不自定义配置文件以及配置类时，会默认读取官方的配置文件：

• 该方法生成实例logger包含内容如下：
  • level=INFO(默认是使用的rootlogger的日志等级)
  • parent=rootlogger(根logger)，其属性如下：
    • handlers只含ConsoleHandler。
    • level=INFO。
• ConsoleHandler属性设置：level=INFO，formatter=SimpleFormatter
• FileHandler属性设置：pattern=%h/java%u.log，limit=50000，count = 1，formatter=XMLFormatter。

注意：当对应的handler、formatter初始化时会根据配置文件中的属性进行设置的。

执行流程总结

当logger实例调用severe(msg)或其他等级方法或log(level,msg)时，就会执行该流程：

1. 首先比对的是logger实例的level，参数传入的level一定要比其>=才可继续执行。
2. 执行logger实例的中filter过滤器，若是无过滤器或该过滤器方法返回false继续执行。
3. 开始遍历logger实例中的handlers数组(list转数组)。
   • 每一个handler都有重要的两步，①传入参数level比对该handler的level，只有>=才可继续执行；②执行该handler中的fiter，若为null或执行fliter返回false继续执行。两步都通过就会进行输出日志(根据handler输出指向)。
4. 接着判断logger实例的useParentHandlers这个布尔参数，若是为true，则获取到父级logger，遍历父级logger的handlers，与第3步相同。

默认情况下logger实例的level为INFO，rootlogger的level为INFO(其中handler的等级为INFO)。

参考资料

视频：2020年Java进阶教程，全面学习多种java日志框架

[1]. Java日志——JUL（java.util.logging）的使用及原理

[2]. 日志处理器——Java日志 解决了我setUseParentHandlers(false)疑惑

[3]. Java Logging之JUL系列——Log Levels 这个博主出了jul一个系列，在java栏目中很有帮助

[4]. Java Logging之JUL系列——Handler

[5]. Java Logging之JUL系列——Logger Hierarchy Logger的层级关系

[6]. Java中getResourceAsStream的用法 用来读取日志配置文件

[7]. System.getProperty()-获取系统参数 System.getProperty()-获取系统参数

[8]. java.util.logging.LogManager 源码中java.util.logging.config.class以及java.util.logging.config.file对应用途

[9]. JUL(java.util.logging)java原生官方日志 使用与配置–解决jul不输出显示日志问题

[10]. java.util.logging使用笔记2 类中使用方法

[11]. 日志框架1—多种日志门面和日志实现初步了解