Java 日志组件（二）

3、log4j2

　　log4j2与log4j发生了很大变化，不兼容。log4j仅仅作为一个实际的日志框架，slf4j、commons-logging作为门面统一各种日志框架的混乱格局，现在log4j2也想跳出来当门面，也想统一大家。日志越来越乱了

• log4j-api：作为日志接口层，用于统一底层日志系统。
• log4j-core：作为上述日志接口的实现，是一个实际的日志框架。

　　3.1、maven依赖

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.2</version>
</dependency>

　　3.2、使用方式

• • 编写log4j2.xml配置文件（目前log4j2只支持xml、json、yuml，不再支持properties）

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="debug">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

• • 使用

private static final Logger logger=LogManager.getLogger(Log4j2Test.class);

public static void main(String[] args){
    if(logger.isTraceEnabled()){
        logger.debug("log4j trace message");
    }
    if(logger.isDebugEnabled()){
        logger.debug("log4j debug message");
    }
    if(logger.isInfoEnabled()){
        logger.debug("log4j info message");
    }
}

　　　　和log4j不同的是此时的Logger是log4j-api中定义的接口，而log4j中的Logger是类

　　3.3、使用过程简单分析

• • 获取底层使用的LoggerContextFactory

　　　　　　　　同样LogManager的类加载会去寻找log4j-api定义的LoggerContextFactory接口的底层实现，获取方式有三种

• • • 尝试从jar中寻找log4j2.component.properties文件，如果配置了log4j2.loggerContextFactory则使用该LoggerContextFactory。
    • 如果没找到，尝试从jar包中寻找META-INF/log4j-provider.properties文件，如log4j-core-2.2中就有该文件。
    • 如果找到多个，取优先级最高的（该文件中指定了LoggerContextFactory，同时指定了优先级FactoryPriority），如log4j-core-2.2中log4j-provider.properties的文件内容如下　

LoggerContextFactory = org.apache.logging.log4j.core.impl.Log4jContextFactory
Log4jAPIVersion = 2.1.0
FactoryPriority= 10

• • • 上述方式还没找到，就使用默认的SimpleLoggerContextFactory

• • 使用LoggerContextFactory获取LoggerContext
  • 根据LoggerContext获取Logger
    • 会首先判断LoggerContext是否被初始化过了，没有则进行初始化
    • 获取ConfigurationFactory,从配置中获取和插件中获取（log4j-core核心包中有三个YamlConfigurationFactory、JsonConfigurationFactory、XmlConfigurationFactory）
    • 以上文的案例中，会使用XmlConfigurationFactory来加载log4j2.xml配置文件
    • LoggerContext初始化后，就可以获取或者创建Logger了

　　3.4、主要对象总结

• • LogManager： 它的类加载会去寻找LoggerContextFactory接口的底层实现，会从jar包中的配置文件中寻找，如上面所述

  • LoggerContextFactory ： 用于创建LoggerContext，不同的日志实现系统会有不同的实现，如log4j-core中的实现为Log4jContextFactory

  • PropertyConfigurator: 用于解析log4j.properties文件

  • LoggerContext : 它包含了配置信息，并能创建log4j-api定义的Logger接口实例，并缓存这些实例

  • ConfigurationFactory：上述LoggerContext解析配置文件，需要用到ConfigurationFactory，目前有三个YamlConfigurationFactory、JsonConfigurationFactory、XmlConfigurationFactory，分别解析yuml json xml形式的配置文件

4、logback

• • logback-core
  • logback-classic
  • slf4j-api

　　4.1、对应maven的依赖

<dependency> 
    <groupId>ch.qos.logback</groupId> 
    <artifactId>logback-core</artifactId> 
    <version>1.1.3</version> 
</dependency> 
<dependency> 
    <groupId>ch.qos.logback</groupId> 
    <artifactId>logback-classic</artifactId> 
    <version>1.1.3</version> 
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.12</version>
</dependency>

　　4.2、使用

private static final Logger logger=LoggerFactory.getLogger(LogbackTest.class);

public static void main(String[] args){
    if(logger.isDebugEnabled()){
        logger.debug("slf4j-logback debug message");
    }
    if(logger.isInfoEnabled()){
        logger.debug("slf4j-logback info message");
    }
    if(logger.isTraceEnabled()){
        logger.debug("slf4j-logback trace message");
    }
    
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    StatusPrinter.print(lc);
}

• • 官方使用方式，其实就和slf4j集成了起来

    上述的Logger、LoggerFactory都是slf4j自己的接口与类

  • 没有配置文件的情况下，使用的是默认配置。搜寻配置文件的过程如下：

Logback tries to find a file called logback.groovy in the classpath.
If no such file is found, logback tries to find a file called logback-test.xml in the classpath.
If no such file is found, it checks for the file logback.xml in the classpath..
If no such file is found, and the executing JVM has the ServiceLoader (JDK 6 and above) the ServiceLoader will be used to resolve an implementation of com.qos.logback.classic.spi.Configurator. The first implementation found will be used. See ServiceLoader documentation for more details
If none of the above succeeds, logback configures itself automatically using the BasicConfigurator which will cause logging output to be directed to the console.
The fourth and last step is meant to provide a default (but very basic) logging functionality in the absence of a configuration file

　　也可以在类路径上加一个类似如下的logback.xml的配置文件，logback则会去解析对应的配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
  </appender>

  <root level="DEBUG">          
    <appender-ref ref="STDOUT" />
  </root>  
  
</configuration>

　　4.3、使用过程简单分析

• • slf4j与底层的日志系统进行绑定在jar包中寻找org/slf4j/impl/StaticLoggerBinder.class 这个类，如在logback-classic中就含有这个类，如果找到多个StaticLoggerBinder，则表明目前底层有多个实际的日志框架，slf4j会随机选择一个。
  • 使用上述找到的StaticLoggerBinder创建一个实例，并返回一个LoggerFactory实例：

return StaticLoggerBinder.getSingleton().getLoggerFactory()

　　　　　　以logback-classic中的StaticLoggerBinder为例，在StaticLoggerBinder.getSingleton()过程中：会去加载解析配置文件 源码如下

public URL findURLOfDefaultConfigurationFile(boolean updateStatus) {
    ClassLoader myClassLoader = Loader.getClassLoaderOfObject(this);
    //寻找logback.configurationFile的系统属性
    URL url = findConfigFileURLFromSystemProperties(myClassLoader, updateStatus);
    if (url != null) {
      return url;
    }
    //寻找logback.groovy
    url = getResource(GROOVY_AUTOCONFIG_FILE, myClassLoader, updateStatus);
    if (url != null) {
      return url;
    }
    //寻找logback-test.xml
    url = getResource(TEST_AUTOCONFIG_FILE, myClassLoader, updateStatus);
    if (url != null) {
      return url;
    }
    //寻找logback.xml
    return getResource(AUTOCONFIG_FILE, myClassLoader, updateStatus);
}

　　　　目前路径都是定死的，只有logback.configurationFile的系统属性是可以更改的，所以如果我们想更改配置文件的位置（不想放在类路径下），则需要设置这个系统属性：

System.setProperty("logback.configurationFile", "/path/to/config.xml");

　　　　解析完配置文件后，返回的LoggerFactory实例的类型是LoggerContext（它包含了配置信息）

• • 根据返回的LoggerFactory实例，来获取Logger就是根据上述的LoggerContext来创建一个Logger，每个logger与LoggerContext建立了关系，并放到LoggerContext的缓存中，就是LoggerContext的如下属性：

private Map<String, Logger> loggerCache;

　　　　其实上述过程就是slf4j与其他日志系统的绑定过程。不同的日志系统与slf4j集成，都会有一个StaticLoggerBinder类，并会拥有一个LoggerFactory的实现。