Java 日志系列篇一 原生 Java.util.logging

摘要：理解在记录消息中的日志的不同级别是非常重要的。通常来说，当为指定了一个该会包含当前指定级别以及更高级别的日志。，将消息发送至单个一般文件或一个可回滚的文件集合。

本文网大多网络整理所得，出处太多，不一一列举

Java 中的 Logging API 让 Java 应用可以记录不同级别的信息，它在debug过程中非常有用，如果系统因为各种各样的原因而崩溃，崩溃原因可以在日志中清晰地追溯，下面让我们来看看 Java 原生的 Logging 功能。
从1.4.2开始，Java 通过 Java.util.logging 包为应用程序提供了记录消息的可能，在 API 中的核心类为 Logger 类。理解在记录消息中的日志的不同级别是非常重要的。Java 为此定时了8个级别，它们是分别SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST 以及 ALL. 它们按照优先级降序排列，在应用运行的任何时间点，日志级别可以被更改。
通常来说，当为 Logger 指定了一个 Level, 该 Logger 会包含当前指定级别以及更高级别的日志。举例而言，如果 Level 被设置成了 WARNING, 所有的 warning 消息以及 SERVER 消息会被记录。应用可以用下列方法记录日志：Logger.warning(), Logger.info(), Logger.config() ...

Logger 对外发布的日志记录器，应用系统可以通过该对象完成日志记录的功能

Level 日志的记录级别

LoggingMXBean 接口对象，对外发布的日志管理器

LogRecord 日志信息描述对象

LoggerManager 日志管理器

Filter 日志过滤器，接口对象，在日志被 Handler 处理之前，起过滤作用

Handler 日志处理器，接口对象，决定日志的输出方式

Formatter 日志格式化转换器，接口对象，决定日志的输出格式

首先通过LoggerManager进行日志框架的初始化，生成Logger的根节点RootLogger. 这里需要注意的是LoggerManager的初始化工作，并没有将构建配置文件中所有的日志对象，而仅仅是构建了根节点，这种方式就是我们多例模式中经常用到的懒加载，对象只有在真正被时候的时候，再进行构建。 
通过Logger.getLogger(String name) 获取一个已有的Logger对象或者是新建一个Logger对象。Logger,日志记录器，这就是在应用程序中需要调用的对象了，通过Logger对象的一系列log方法，

收到应用程序的记录请求，将参数中的日志信息和运行时的信息构建出LogRecord对象，而后通过Logger对象本身设置的记录级别和调用者传递进来的日志级别，如果传递进来的日志级别低于Logger对象本身设置的记录级别（从语义上的理解，而实际上语义级别越高的级别其内部用数字表示的标志的数值越小），那么Logger对象将直接返回，因为他认为这条日志信息，在当前运行环境中，没有必要记录。 
 而满足以上条件的日志信息，将会通过Logger对象的filter元素的过滤校验，filter是动态的，在运行时是可以随意设置的，如果有filter对象，那么将调用filter对象，对日志对象LogRecord进行校验，只有校验通过的LogRecord对象，才会继续往下执行。 
 通过filter校验后，Logger对象将依次调用其配置的处理器，通过处理器来真正实现日志的记录功能，一个Logger对象可以配置多个处理器handler,所以一条日志记录可以被多个处理器处理，同时Logger对象的实现是树形结构，如果Logger对象设置其可以继承其父节点的处理器（默认），一条日志记录还会被其父节点的Logger对象处理。  而handler的处理方式就会是形形色色了，但是归根节点，会有以下几个大的步骤： 
1. 级别的判定和比较，决定某条具体的日志记录是否应该继续处理 
2. 将日志记录做格式化处理，以达到输出的日志在格式上统一，美观，可读性高。 3. 资源的释放，不管是以何种方式记录日志，总是会消耗一些方面的资源，所以
会涉及到资源的释放问题。比如以文件方式记录的日志的，在一定的时候需要做文件关闭操作，以报文方式发送日志的，在和远程通话的过程中，也需要涉及到网络IO的关闭操作，或者是存储在数据库等等，资源释放在程序开发过程中，是个不变的主题。

public class TestLogger {
    public static void main(String[] args) {
        Logger log = Logger.getLogger("lavasoft");
        log.info("aaa");
    }
}

console output:
>>> aaa

以上简单的代码背后发生那些事

LoggerManager 将会返回一个新的或者已经存在的同名的 Logger , 首先会查找是否有同名 Logger 被 namedLoggers 维护有则返回, 但是在我们这个示例中大多是重新生成一个 Logger，首先 LoggerManager 会读取系统配置，设定一个默认的的 INFO 级别的 Logger, 然后也许跟其他线程抢到一个 Logger 后返回
tips:
默认的Java日志框架将其配置存储到一个名为 logging.properties 的文件中。
在这个文件中，每行是一个配置项，配置项使用点标记（dot notation）的形式。
Java在其安装目录的lib文件夹下面安装了一个全局配置文件，但在启动一个Java程序时，
你可以通过指定 java.util.logging.config.file 属性的方式来使用一个多带带的日志配置文件，
同样也可以在个人项目中创建和存储 logging.properties 文件。

Logger 中召唤 LoggerManager 片段
---------------------------

public static Logger getLogger(String name) {
    LogManager manager = LogManager.getLogManager();
    return manager.demandLogger(name);
}


LoggerManager 中 产生 Logger 的片段
-----------------------------

Logger demandLogger(String name) {
    Logger result = getLogger(name);
    if (result == null) {
        Logger newLogger = new Logger(name, null);
        do {
            if (addLogger(newLogger)) {
                return newLogger;
            }
            result = getLogger(name);
        } while (result == null);
    }
    return result;
}



LoggerManager 中维护了一个有继承关系的含有弱引用的 LoggerWeakRef
-------------------------------
private Hashtable namedLoggers = new Hashtable<>();

LoggerWeakRef 类结构
-----------------

final class LoggerWeakRef extends WeakReference {
    private String                name;       // for namedLoggers cleanup
    private LogNode               node;       // for loggerRef cleanup
    private WeakReference parentRef;  // for kids cleanup

以上两者维护了JVM中弱引用的 Loggers 父子结构

log.info()

Logger 中的 info(String msg) 方法
-----------------------------

   public void info(String msg) {
 if (Level.INFO.intValue() < levelValue) {
     return;
 }
 log(Level.INFO, msg);
   }
   
   上面说过默认 LoggerManager 产生的 Logger 日志级别默认为 INFO ，所以这里默认的
   levelValue 为 Level.INFO.intValue()
   
   如果这里 Level.INFO.intValue() 低于 levelValue 的 , 将 do nothing
   

调用 log(Level level, String msg) 方法
----------------------------------

   public void log(Level level, String msg) {
 if (level.intValue() < levelValue || levelValue == offValue) {
     return;
 }
 LogRecord lr = new LogRecord(level, msg);
 doLog(lr);
   }
   上面的 log.info 方法只是 log(Level level, String msg) 方法简单封装，在这里日志级别
   为 Level.OFF.intValue() 也 do nothing  了，否则创建真正的 LogRecord 对象
   

调用 doLog(LogRecord lr) 方法
-------------------------
   private void doLog(LogRecord lr) {
 lr.setLoggerName(name);
 String ebname = getEffectiveResourceBundleName();
 if (ebname != null) {
     lr.setResourceBundleName(ebname);
     lr.setResourceBundle(findResourceBundle(ebname));
 }
 log(lr);
   }
   
   getEffectiveResourceBundleName() 将一直上溯查找有效的 resourceBundleName , 有可能返回 null
   

调用 log(LogRecord lr) 方法
-----------------------
  public void log(LogRecord record) {
 if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
     return;
 }
 Filter theFilter = filter;
 if (theFilter != null && !theFilter.isLoggable(record)) {
     return;
 }

 // Post the LogRecord to all our Handlers, and then to
 // our parents" handlers, all the way up the tree.

 Logger logger = this;
 while (logger != null) {
     for (Handler handler : logger.getHandlers()) {
         handler.publish(record);
     }

     if (!logger.getUseParentHandlers()) {
         break;
     }

     logger = logger.getParent();
 }
   }
 
   在这里我们可以看到了 Filter 与 Handler 的出现，我们可以使用 setFilter(Filter newFilter)
   与 addHandler(Handler handler) 来为 Logger 添加 Filter 与 Handler
   这里我们可以看出在 while 循环中会先对当前所有 handler 输出，在上溯所有父 Logger 所有 Handler
   输出，至此两句代码解析结束。

作为一个接口, Filter:为所记录的日志提供日志级别控制以外的细粒度控制。

public interface Filter {

    /**
     * Check if a given log record should be published.
     * @param record  a LogRecord
     * @return true if the log record should be published.
     */
    public boolean isLoggable(LogRecord record);

}

我们可以实现一个 Filter 接口的的对象来使用，下面是示例代码

public class MyFilter implements Filter {
    public boolean isLoggable(LogRecord record) {
        // TODO: 在这里我们可以添加自己的一些逻辑进去
        return false;
        // 返回 false 则不被记录日志， true 则被记录日志
    }
}

然后我们为 Logger 对象设定 Filter 对象

Filter filter = new MyFilter();
logger1.setFilter(filter); 

或者我们也可以为 Handler 对象设定 Filter 对象

Filter filter = new MyFilter();
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setLevel(Level.ALL);
consoleHandler.setFilter(filter);

先上一张 java.util.logging 包中有关 Handler 的类图

Handler负责从Logger中取出日志消息并将消息发送出去，比如发送到控制台、文件、网络上的其他日志服务或操作系统日志等。
Handler也具有级别概念，用于判断当前Logger中的消息是否应该被发送出去，可以使用定义好的各种日志级别（如Level.OFF表示关闭等）。
除了级别概念，一个Handler还可以具有自己的过滤器（Filter）、格式化器（Formatter）、错误管理器（ErrorManager）以及编码字符集等，这些属性借助LogManager中的配置信息进行设置。
Handler是一个抽象类，需要根据实际情况创建真正使用的具体Handler（如ConsoleHandler、FileHandler等），实现各自的publish、flush以及close等方法。
对几种具体实现 Handler 类的类做简单说明

MemoryHandler，将当前日志信息写入内存缓冲区中同时丢弃缓存中以前的内容。将内存缓冲区中的信息转发至另一个Handler

StreamHandler所有基于I/O流的Handler的基类，将日志信息发送至给定的java.io.OutputStream中

ConsoleHandler，将消息发送至System.err（而非System.out），默认配置与其父类StreamHandler相同。

FileHandler，将消息发送至单个一般文件或一个可回滚的文件集合。可回滚文件集中的文件依据文件大小进行回滚，久文件名称通过当前文件名附加编号0、1、2等方式依次进行标示。默认情况下日志信息都存放在I/O缓冲中，但如果一条完整的日志信息会触发清空缓冲的动作。与其父类StramHandler不同的是，FileHandler的默认格式器是java.util.logging.XMLFormatter：

SocketHandler，负责将日志信息发送至网络，默认情况下也采用java.util.logging.XMLFormatter格式。

MemoryHandler 使用了典型的“注册 - 通知”的观察者模式。MemoryHandler 先注册到对自己感兴趣的 Logger 中（logger.addHandler(handler)），在这些 Logger 调用发布日志的 API：log()、logp()、logrb() 等，遍历这些 Logger 下绑定的所有 Handlers 时，通知触发自身 publish（LogRecord）方法的调用，将日志写入 buffer，当转储到下一个日志发布平台的条件成立，转储日志并清空 buffer。

这里的 buffer 是 MemoryHandler 自身维护一个可自定义大小的循环缓冲队列，来保存所有运行时触发的 Exception 日志条目。同时在构造函数中要求指定一个 Target Handler，用于承接输出；在满足特定 flush buffer 的条件下，如日志条目等级高于 MemoryHandler 设定的 push level 等级（实例中定义为 SEVERE）等，将日志移交至下一步输出平台。从而形成如下日志转储输出链：

MemoryHandler 使用方式

以上是记录产品 Exception 错误日志，以及如何转储的 MemoryHandler 处理的内部细节；接下来给出 MemoryHandler 的一些使用方式。

直接使用 java.util.logging 中的 MemoryHandler

// 在 buffer 中维护 5 条日志信息
// 仅记录 Level 大于等于 Warning 的日志条目并
// 刷新 buffer 中的日志条目到 fileHandler 中处理
int bufferSize = 5; 
f = new FileHandler("testMemoryHandler.log"); 
m = new MemoryHandler(f, bufferSize, Level.WARNING); 
myLogger = Logger.getLogger("com.ibm.test"); 
myLogger.addHandler(m); 
myLogger.log(Level.WARNING, “this is a WARNING log”);

自定义（反射）
思考自定义 MyHandler 继承自 MemoryHandler 的场景，由于无法直接使用作为父类私有属性的 size、buffer 及 buffer 中的 cursor，如果在 MyHandler 中有获取和改变这些属性的需求，一个途径是使用反射。清单 5 展示了使用反射读取用户配置并设置私有属性。

 int m_size; 
  String sizeString = manager.getProperty(loggerName + ".size"); 
  if (null != sizeString) { 
         try { 
          m_size = Integer.parseInt(sizeString); 
          if (m_size <= 0) { 
             m_size = BUFFER_SIZE; // default 1000 
          } 
 // 通过 java 反射机制获取私有属性
          Field f; 
          f = getClass().getSuperclass().getDeclaredField("size"); 
          f.setAccessible(true); 
          f.setInt(this, m_size); 
          f = getClass().getSuperclass().getDeclaredField("buffer"); 
          f.setAccessible(true); 
          f.set(this, new LogRecord[m_size]); 
         } catch (Exception e) { 
         } 
  }

自定义（重写）
直接使用反射方便快捷，适用于对父类私有属性无频繁访问的场景。思考这样一种场景，默认环形队列无法满足我们存储需求，此时不妨令自定义的 MyMemoryHandler 直接继承 Handler，直接对存储结构进行操作，可以通过清单 6 实现。

 public class MyMemoryHandler extends Handler{ 
  // 默认存储 LogRecord 的缓冲区容量
  private static final int DEFAULT_SIZE = 1000; 
  // 设置缓冲区大小
  private int size = DEFAULT_SIZE; 
  // 设置缓冲区
  private LogRecord[] buffer; 
  // 参考 java.util.logging.MemoryHandler 实现其它部分
  ... 
 }

默认的 logging.properties 存放在 jre/lib/logging.properties，截取有效的配置项

handlers= java.util.logging.ConsoleHandler
.level= INFO
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
com.xyz.foo.level = SEVERE