Log4j2完全讲解 附项目集成源码下载

Log4j2完全讲解

    本文内容大多翻译自log4j官网。

    Apache的开源项目log4j（log for java）是一个功能强大的日志组件,提供方便的日志记录。在apache网站：http://www.apache.org/dyn/closer.cgi/logging/log4j 可以免费下载到Log4j最新版本的软件包。

    但是，后来Apache软件基金会发布了Log4j 2.0通用版本，相比之前Log4j的1.x版本有了很大的性能提升。本版本的灵感来自于诸如Log4j 1.x和java.util.logging之类的已有日志解决方案，它是经过了数年的努力从头开始编写完成的。 Log4j 2.0引入了新的插件系统、对properties的支持、对基于 JSON配置的支持和配置的自动化重载。它支持很多已有的日志框架，包括SLF4J、Commons Logging、Apache Flum、Log4j 1.x，并提供了新的程序员API。

    截止发帖时间Log4j2最新版本是 2015.12.10 5:00发布的2.5版本。

1、认识log4j2

    日志是应用软件中不可缺少的部分，服务器后期的维护，日志是最重要的一个依据。

    Apache log4j(log for java)是 Apache 软件基金会项目和由提交者的 Apache 软件基金会专门团队开发。

    Apache Log4j2是 Log4j 1.x的重构，提供的许多改进可用在 Logback，同时修复Logback的体系结构中的一些固有的问题。

    1.2、Log4j 2中的改进

      1.2.1、API 分离

    Log4j的API是独立于实现明确的类和方法，应用程序开发人员可以使用同时确保向前兼容性。

      1.2.2、更好的性能

    Log4j2基于LMAX Disruptor library的下一代异步记录器。在多线程方案中异步记录器相比Log4j 1.x和Logback有18倍的日志记录效率和更低的延迟。详细信息，请参阅性能。

      1.2.3、更加先进的Api支持

    Log4j 2 API提供了最佳的性能，但同时，Log4j2提供了对SLF4J和Commons Logging APIs的支持。

    在这之前，程序员们以如下方式进行日志记录：

    
    
    
    

     
     
     
     
if(logger.isDebugEnabled()) {
     
     
     
     
logger.debug("Hi, " + u.getA() + “ “ + u.getB());
     
     
     
     
}
    
    
    
    

    许多人都会抱怨上述代码的可读性太差了。如果有人忘记写if语句，程序输出中会多出很多不必要的字符串。log4j 2.0开发团队鉴于以上考虑对API进行了完善。现在你可以这样写代码：

    
    
    
    

     
     
     
     
logger.debug("Hi, {} {}", u.getA(), u.getB());
    
    
    
    

    和其它一些流行的日志框架一样， 新的API也支持变量参数的占位符功能。 log4j 2.0还支持其它一些很棒的功能，像Markers和flow tracing：

    
    
    
    

     
     
     
     
private Logger logger = LogManager.getLogger(MyApp.class.getName());
     
     
     
     
private static final Marker QUERY_MARKER = MarkerManager.getMarker("SQL");
     
     
     
     
...
     
     
     
     
public String doQuery(String table) {
     
     
     
     
logger.entry(param);
     
     
     
     
logger.debug(QUERY_MARKER, "SELECT * FROM {}", table);
     
     
     
     
 return logger.exit();
     
     
     
     
}
    
    
    
    

    Markers可以帮助你很快地找到具体的日志项（Log Entries）。而在某个方法的开头和结尾调用Flow Traces中的一些方法，你可以在日志文件中看到很多新的跟踪层次的日志项，也就是说，你的程序工作流（Program Flow）被记录下来了。下面是Flow Traces的一些例子：

    
    
    
    

     
     
     
     
19:08:07.056 TRACE com.test.TestService 19 retrieveMessage - entry
     
     
     
     
19:08:07.060 TRACE com.test.TestService 46 getKey - entry
    
    
    
    

      1.2.4、配置自动重新加载

    自动重新加载配置文件：

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 monitorInterval="30">
    
    
    
    
...
    
    
    
    

   
   
   
   

    监控的时间间隔单位为秒，最小值是5。这意味着，log4j 2在配置改变的情况下可以重新配置日志记录行为。如果值设置为0或负数，log4j 2不会对配置变更进行监测。最为称道的一点是：不像其它日志框架， log4j 2.0在重新配置的时候不会丢失之前的日志记录。

    本次使用的基本工程是Spring4 MVC + Hibernate5 为基础工程，然后集成log4j2。

    log4j2最好的教程在 这里 。

      1.2.5、插件式的架构

    log4j 2.0支持插件式的架构。你可以根据需要自行扩展log4j 2.0，这非常简单。首先，你要为你的扩展建立好命名空间，然后告诉log4j 2.0在哪能够找到它：

   
   
   
   

    
    
    
    
 … packages="de.grobmeier.examples.log4j2.plugins">
   
   
   
   

    根据上述配置，log4j 2将会在de.grobmeier.examples.log4j2.plugins包中找寻你的扩展插件。如果你建立了多个命名空间，没关系，用逗号分隔就可以了。 下面是一个简单的扩展插件：

    
    
    
    

     
     
     
     
@Plugin(name = "Sandbox", type = "Core", elementType = "appender")
     
     
     
     
public class SandboxAppender extends AppenderBase {
     
     
     
     
 private SandboxAppender(String name, Filter filter) {
     
     
     
     
 super(name, filter, null);
     
     
     
     
 }
     
     
     
     
 public void append(LogEvent event) {
     
     
     
     
 System.out.println(event.getMessage().getFormattedMessage());
     
     
     
     
 }
     
     
     
     
 @PluginFactory
     
     
     
     
 public static SandboxAppender createAppender(
     
     
     
     
 @PluginAttr("name") String name,
     
     
     
     
 @PluginElement("filters") Filter filter) {
     
     
     
     
 return new SandboxAppender(name, filter);
     
     
     
     
 }
     
     
     
     
}
    
    
    
    

    上面标有@PluginFactory注解的方法是一个工厂，它的两个参数直接从配置文件读取。用@PluginAttr和@PluginElement进行了实现。剩下的就非常简单了。由于写的是一个Appender，因此得继承AppenderBase这个类。该类必须实现append()方法，从而进行实际的逻辑处理。除了Appender，你甚至可以实现自己的Logger和Filter。可以参看官方文档。

2、log4j2更多介绍

    2.1、基本配置介绍

    

    Logger间的层次关系

    相比于纯粹的System.out.println方式，使用logging API的最首要以及最重要的优势是可以在禁用一些log语句块的同时允许其他的语句块的输出。这一能力建立在一种假设之上，即所有在应用中可能出现的logging语句可以按照开发者定义的标准分成不同的类型。 在 Log4j 1.x版本时，Logger的层次是靠Logger类之间的关系来维护的。

    但在Log4j2中， Logger的层次则是靠LoggerConfig对象之间的关系来维护的。 Logger和LoggerConfig均是有名称的实体。Logger的命名是大小写敏感的，并且服从如下的分层命名规则。（与java包的层级关系类似）。例如：com.foo是com.foo.Bar的父级；java是java.util的父级，是java.util.vector的祖先。

    root LoggerConfig位于LoggerConfig层级关系的最顶层。它将永远存在与任何LoggerConfig层次中。

    任何一个希望与root LoggerConfig相关联的Logger可以通过如下方式获得： Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    其他的Logger实例可以调用LogManager.getLogger 静态方法并传入想要得到的Logger的名称来获得。

    Configuration：

    Configuration包含了所有的Appenders、上下文范围内的过滤器、LoggerConfigs以及StrSubstitutor.的引用。在重配置期间，新与旧的Configuration将同时存在。当所有的Logger对象都被重定向到新的Configuration对象后，旧的Configuration对象将被停用和丢弃。

    Logger：

    Loggers 是通过调用LogManager.getLogger方法获得的。Logger对象本身并不实行任何实际的动作。它只是拥有一个name 以及与一个LoggerConfig相关联。它继承了AbstractLogger类并实现了所需的方法。当Configuration改变时，Logger将会与另外的LoggerConfig相关联，从而改变这个Logger的行为。

    获得Logger： 使用相同的名称参数来调用getLogger方法将获得来自同一个Logger的引用。
    如： Logger x = Logger.getLogger("wombat"); Logger y = Logger.getLogger("wombat"); x和y指向的是同一个Logger对象。
    log4j环境的配置是在应用的启动阶段完成的。优先进行的方式是通过读取配置文件来完成。
    log4j使采用类名（包括完整路径）来定义Logger 名变得很容易。这是一个很有用且很直接的Logger命名方式。使用这种方式命名可以很容易的定位这个log message产生的类的位置。
    当然，log4j也支持任意string的命名方式以满足开发者的需要。不过，使用类名来定义Logger名仍然是最为推崇的一种Logger命名方式。

    LoggerConfig

    当Logger在configuration中被描述时，LoggerConfig对象将被创建。LoggerConfig包含了一组过滤器。LogEvent在被传往Appender之前将先经过这些过滤器。过滤器中包含了一组Appender的引用。Appender则是用来处理这些LogEvent的。

    Log层次： 每一个LoggerConfig会被指定一个Log层次。可用的Log层次包括TRACE, DEBUG,INFO, WARN, ERROR 以及FATAL。

    需要注意的是，在log4j2中，Log的层次是一个Enum型变量，是不能继承或者修改的。如果希望获得跟多的分割粒度，可用考虑使用Markers来替代。

    在Log4j 1.x 和Logback 中都有“层次继承”这么个概念。

    但是在log4j2中，由于Logger和LoggerConfig是两种不同的对象，因此“层次继承”的概念实现起来跟Log4j 1.x 和Logback不同。

    LoggerContext

    LoggerContext在Logging System中扮演了锚点的角色。根据情况的不同，一个应用可能同时存在于多个有效的LoggerContext中。

    在同一LoggerContext下，log system是互通的。如：Standalone Application、Web Applications、Java EE Applications、"Shared" Web Applications 和REST Service Containers，就是不同广度范围的log上下文环境。

    Filter

    与防火墙过滤的规则相似，log4j2的过滤器也将返回三类状态：Accept（接受）, Deny（拒绝） 或Neutral（中立）。

    其中，Accept意味着不用再调用其他过滤器了，这个LogEvent将被执行；
    Deny意味着马上忽略这个event，并将此event的控制权交还给过滤器的调用者；
    Neutral则意味着这个event应该传递给别的过滤器，如果再没有别的过滤器可以传递了，那么就由现在这个过滤器来处理。

    Appender

    由logger的不同来决定一个logging request是被禁用还是启用只是log4j2的情景之一。log4j2还允许将logging request中log信息打印到不同的目的地中。

    在log4j2的世界里，不同的输出位置被称为Appender。目前，Appender可以是console、文件、远程socket服务器、Apache Flume、JMS以及远程 UNIX 系统日志守护进程。

    一个Logger可以绑定多个不同的Appender。 可以调用当前Configuration的addLoggerAppender函数来为一个Logger增加。如果不存在一个与Logger名称相对应的LoggerConfig，那么相应的LoggerConfig将被创建，并且新增加的Appender将被添加到此新建的LoggerConfig中。而后，所有的Loggers将会被通知更新自己的LoggerConfig引用（PS：一个Logger的LoggerConfig引用是根据名称的匹配长度来决定的，当新的LoggerConfig被创建后，会引发一轮配对洗牌）。

    在某一个Logger中被启用的logging request将被转发到该Logger相关联的的所有Appenders上，并且还会被转发到LoggerConfig的父级的Appenders上。 这样会产生一连串的遗传效应。例如，对LoggerConfig B来说，它的父级为A，A的父级为root。如果在root中定义了一个Appender为console，那么所有启用了的logging request都会在console中打印出来。

    另外，如果LoggerConfig A定义了一个文件作为Appender，那么使用LoggerConfig A和LoggerConfig B的logger 的logging request都会在该文件中打印，并且同时在console中打印。 如果想避免这种遗传效应的话，可以在configuration文件中做如下设置： additivity="false" 这样，就可以关闭Appender的遗传效应了。

    目前支持的日志存放方式：
    

    Layout

    通常，用户不止希望能定义log输出的位置，还希望可以定义输出的格式。这就可以通过将Appender与一个layout相关联来实现。

    Log4j中定义了一种类似C语言printf函数的打印格式，如"%r [%t] %-5p %c - %m%n" 格式在真实环境下会打印类似如下的信息： 176 [main] INFO org.foo.Bar - Located nearest gas station.

    其中，各个字段的含义分别是：
        %r 指的是程序运行至输出这句话所经过的时间（以毫秒为单位）； 
        %t 指的是发起这一log request的线程； 
        %c 指的是log的level； 
        %m 指的是log request语句携带的message。 
        %n 为换行符。

    优先级：

    log4j2中的日志一般分8个级别：ALL、TRACE、DEBUG、INFO、WARN、ERROR、FATAL、OFF。

    其中ALL为所有日志，OFF为关闭日志，所以，其实也就是6个级别：
        FATAL：用在极端的情形中，即必须马上获得注意的情况。这个程度的错误通常需要触发运维工程师的寻呼机。 
        ERROR：显示一个错误，或一个通用的错误情况，但还不至于会将系统挂起。这种程度的错误一般会触发邮件的发送，将消息发送到alert list中，运维人员可以在文档中记录这个bug并提交。 
        WARN：不一定是一个bug，但是有人可能会想要知道这一情况。如果有人在读log文件，他们通常会希望读到系统出现的任何警告。 
        INFO：用于基本的、高层次的诊断信息。在长时间运行的代码段开始运行及结束运行时应该产生消息，以便知道现在系统在干什么。但是这样的信息不宜太过频繁。 
        DEBUG：用于协助低层次的调试。 
        TRACE：用于展现程序执行的轨迹。 

    这8个级别优先级从低到高为：ALL

    当过滤器设置为某一级别时，会默认包含当前级别以及所有更高级别的log信息。

    2.2、部分输出方式介绍

    完整介绍请参考：http://logging.apache.org/log4j/2.x/manual/appenders.html

      2.2.1、控制台

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="STDOUT" target="SYSTEM_OUT">
    
    
    
    
  pattern="%m%n"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="STDOUT"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

      2.2.2、log文件

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="MyFile" fileName="logs/app.log">
    
    
    
    
 
    
    
    
    
 %d %p %c{1.} [%t] %m%n
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="MyFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

      2.2.3、jdbc记录到数据库

    (1)

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="error">
    
    
    
    
 
    
    
    
    
  name="databaseAppender" tableName="dbo.application_log">
    
    
    
    
  jndiName="java:/comp/env/jdbc/LoggingDataSource" />
    
    
    
    
  name="eventDate" isEventTimestamp="true" />
    
    
    
    
  name="level" pattern="%level" />
    
    
    
    
  name="logger" pattern="%logger" />
    
    
    
    
  name="message" pattern="%message" />
    
    
    
    
  name="exception" pattern="%ex{full}" />
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="warn">
    
    
    
    
  ref="databaseAppender"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    (2)

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="error">
    
    
    
    
 
    
    
    
    
  name="databaseAppender" tableName="LOGGING.APPLICATION_LOG">
    
    
    
    
  class="net.example.db.ConnectionFactory" method="getDatabaseConnection" />
    
    
    
    
  name="EVENT_ID" literal="LOGGING.APPLICATION_LOG_SEQUENCE.NEXTVAL" />
    
    
    
    
  name="EVENT_DATE" isEventTimestamp="true" />
    
    
    
    
  name="LEVEL" pattern="%level" />
    
    
    
    
  name="LOGGER" pattern="%logger" />
    
    
    
    
  name="MESSAGE" pattern="%message" />
    
    
    
    
  name="THROWABLE" pattern="%ex{full}" />
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="warn">
    
    
    
    
  ref="databaseAppender"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    

    
    
    
    

     
     
     
     
package net.example.db;
     
     
     
     
import java.sql.Connection;
     
     
     
     
import java.sql.SQLException;
     
     
     
     
import java.util.Properties;
     
     
     
     
import javax.sql.DataSource;
     
     
     
     
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
     
     
     
     
import org.apache.commons.dbcp.PoolableConnection;
     
     
     
     
import org.apache.commons.dbcp.PoolableConnectionFactory;
     
     
     
     
import org.apache.commons.dbcp.PoolingDataSource;
     
     
     
     
import org.apache.commons.pool.impl.GenericObjectPool;
     
     
     
     
public class ConnectionFactory {
     
     
     
     
 private static interface Singleton {
     
     
     
     
 final ConnectionFactory INSTANCE = new ConnectionFactory();
     
     
     
     
 }
     
     
     
     
 private final DataSource dataSource;
     
     
     
     
 private ConnectionFactory() {
     
     
     
     
 Properties properties = new Properties();
     
     
     
     
properties.setProperty("user", "logging");
     
     
     
     
properties.setProperty("password", "abc123"); // or get properties from some configuration file
     
     
     
     
 GenericObjectPool<PoolableConnection> pool = new GenericObjectPool<PoolableConnection>();
     
     
     
     
 DriverManagerConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
     
     
     
     
 "jdbc:mysql://example.org:3306/exampleDb", properties
     
     
     
     
 );
     
     
     
     
 new PoolableConnectionFactory(
     
     
     
     
connectionFactory, pool, null, "SELECT 1", 3, false, false, Connection.TRANSACTION_READ_COMMITTED
     
     
     
     
 );
     
     
     
     
 this.dataSource = new PoolingDataSource(pool);
     
     
     
     
 }
     
     
     
     
 public static Connection getDatabaseConnection() throws SQLException {
     
     
     
     
 return Singleton.INSTANCE.dataSource.getConnection();
     
     
     
     
 }
     
     
     
     
}
    
    
    
    

    2.2.4、压缩文件

    Below is a sample configuration that uses a RollingFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip:

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="logs/app.log"
    
    
    
    
 filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
    
    
    
    
 
    
    
    
    
 %d %p %c{1.} [%t] %m%n
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  />
    
    
    
    
  size="250 MB"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    This second example shows a rollover strategy that will keep up to 20 files before removing them：

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="logs/app.log"
    
    
    
    
 filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
    
    
    
    
 
    
    
    
    
 %d %p %c{1.} [%t] %m%n
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  />
    
    
    
    
  size="250 MB"/>
    
    
    
    
 
    
    
    
    
  max="20"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    Below is a sample configuration that uses a RollingFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip and will roll every 6 hours when the hour is divisible by 6:

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="logs/app.log"
    
    
    
    
 filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
    
    
    
    
 
    
    
    
    
 %d %p %c{1.} [%t] %m%n
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  interval="6" modulate="true"/>
    
    
    
    
  size="250 MB"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    Below is a sample configuration that uses a RollingFileAppender with the cron triggering policy configured to trigger every day at midnight. Archives are stored in a directory based on the current year and month. All files under the base directory that match the "*/app-*.log.gz" glob and are 60 days old or older are deleted at rollover time：

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="baseDir">logs
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="${baseDir}/app.log"
    
    
    
    
 filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd}.log.gz">
    
    
    
    
  pattern="%d %p %c{1.} [%t] %m%n" />
    
    
    
    
  schedule="0 0 0 * * ?"/>
    
    
    
    
 
    
    
    
    
  basePath="${baseDir}" maxDepth="2">
    
    
    
    
  glob="*/app-*.log.gz" />
    
    
    
    
  age="60d" />
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    Below is a sample configuration that uses a RollingFileAppender with both the time and size based triggering policies, will create up to 100 archives on the same day (1-100) that are stored in a directory based on the current year and month, and will compress each archive using gzip and will roll every hour. During every rollover, this configuration will delete files that match "*/app-*.log.gz" and are 30 days old or older, but keep the most recent 100 GB or the most recent 10 files, whichever comes first：

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="warn" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="baseDir">logs
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="${baseDir}/app.log"
    
    
    
    
 filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
    
    
    
    
  pattern="%d %p %c{1.} [%t] %m%n" />
    
    
    
    
 
    
    
    
    
  />
    
    
    
    
  size="250 MB"/>
    
    
    
    
 
    
    
    
    
  max="100">
    
    
    
    
 
    
    
    
    
  basePath="${baseDir}" maxDepth="2">
    
    
    
    
  glob="*/app-*.log.gz">
    
    
    
    
  age="30d">
    
    
    
    
 
    
    
    
    
  exceeds="100 GB" />
    
    
    
    
  exceeds="10" />
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    Below is a sample configuration that uses a RollingFileAppender with the cron triggering policy configured to trigger every day at midnight. Archives are stored in a directory based on the current year and month. The script returns a list of rolled over files under the base directory dated Friday the 13th. The Delete action will delete all files returned by the script：

   
   
   
   

    
    
    
    
xml version="1.0" encoding="UTF-8"?>
    
    
    
    
 status="trace" name="MyApp" packages="">
    
    
    
    
 
    
    
    
    
  name="baseDir">logs
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="${baseDir}/app.log"
    
    
    
    
 filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyyMMdd}.log.gz">
    
    
    
    
  pattern="%d %p %c{1.} [%t] %m%n" />
    
    
    
    
  schedule="0 0 0 * * ?"/>
    
    
    
    
 
    
    
    
    
  basePath="${baseDir}" maxDepth="2">
    
    
    
    
 
    
    
    
    
  name="superstitious" language="groovy">CDATA[
    
    
    
    
 import java.nio.file.*;
    
    
    
    
def result = [];
    
    
    
    
def pattern = ~/\d*\/app-(\d*)\.log\.gz/;
    
    
    
    
pathList.each { pathWithAttributes ->
    
    
    
    
def relative = basePath.relativize pathWithAttributes.path
    
    
    
    
statusLogger.trace 'SCRIPT: relative path=' + relative + " (base=$basePath)";
    
    
    
    
 // remove files dated Friday the 13th
    
    
    
    
def matcher = pattern.matcher(relative.toString());
    
    
    
    
 if (matcher.find()) {
    
    
    
    
def dateString = matcher.group(1);
    
    
    
    
def calendar = Date.parse("yyyyMMdd", dateString).toCalendar();
    
    
    
    
def friday13th = calendar.get(Calendar.DAY_OF_MONTH) == 13 \
    
    
    
    
 && calendar.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY;
    
    
    
    
 if (friday13th) {
    
    
    
    
result.add pathWithAttributes;
    
    
    
    
statusLogger.trace 'SCRIPT: deleting path ' + pathWithAttributes;
    
    
    
    
 }
    
    
    
    
 }
    
    
    
    
 }
    
    
    
    
statusLogger.trace 'SCRIPT: returning ' + result;
    
    
    
    
result;
    
    
    
    
 ]] >
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  level="error">
    
    
    
    
  ref="RollingFile"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

    请原谅我...翻译得好累。只怪我当初没好好学英语，不过读懂问题还是不大。

3、集成log4j2到Spring4 MVC+Hibernate5工程

    3.1、添加依赖(jar包)：

      3.1.1、传统工程方式

    下载jar包， 官方下载地址：http://logging.apache.org/log4j/2.x/download

    下载解压即可看到需要的jar包：

    

    这里，我们需要这3个jar包：

        

    直接拖到eclipse中lib目录下即可。

      3.1.2、Maven工程方式

    这种方式很简单，只需要在pom.xml文件中如下添加依赖：

   
   
   
   

    
    
    
    
 
    
    
    
    
 org.apache.logging.log4j
    
    
    
    
 log4j-api
    
    
    
    
 2.5
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 org.apache.logging.log4j
    
    
    
    
 log4j-core
    
    
    
    
 2.5
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 org.apache.logging.log4j
    
    
    
    
 log4j-web
    
    
    
    
 2.5
    
    
    
    
 runtime
    
    
    
    
 
   
   
   
   

    3.2、配置

    请在web.xml中添加如下代码：

   
   
   
   

    
    
    
    
 
    
    
    
    
 isLog4jAutoInitializationDisabled
    
    
    
    
 false
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 log4jConfiguration
    
    
    
    
 classpath:config/log4j2.xml
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 org.apache.logging.log4j.web.Log4jServletContextListener
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 log4jServletFilter
    
    
    
    
 org.apache.logging.log4j.web.Log4jServletFilter
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 log4jServletFilter
    
    
    
    
 /*
    
    
    
    
 REQUEST
    
    
    
    
 FORWARD
    
    
    
    
 INCLUDE
    
    
    
    
 ERROR
    
    
    
    
 
   
   
   
   

    log4jConfiguration为log4j2的配置文件位置。

    编辑配置(若配置文件不存在则新建)，配置为每个不同级别的输出到不同文件，并增加一个按单文件大小自动压缩的日志：

   
   
   
   

    
    
    
    
 status="off" debug="off" monitorInterval="1800">
    
    
    
    
 
    
    
    
    
  name="log_path">d://logs
    
    
    
    
  name="log_file">%d{yyyy-MM-dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n
    
    
    
    
  name="log_console">%d{HH:mm:ss.SSS z} %-5level %class{36}.%M()/%L - %msg%xEx%n
    
    
    
    
  name="every_file_size">10M
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  name="Console" target="SYSTEM_OUT">
    
    
    
    
  level="all" onMatch="ACCEPT" onMismatch="DENY"/>
    
    
    
    
  pattern="${log_console}" />
    
    
    
    
 
    
    
    
    
  name="app_all" fileName="${log_path}/all.log" append="false">
    
    
    
    
 
    
    
    
    
  level="all" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_trace" fileName="${log_path}/trace.log" append="false">
    
    
    
    
 
    
    
    
    
  level="debug" onMatch="DENY" onMismatch="NEUTRAL" />
    
    
    
    
  level="trace" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_debug" fileName="${log_path}/debug.log" append="false">
    
    
    
    
 
    
    
    
    
  level="info" onMatch="DENY" onMismatch="NEUTRAL" />
    
    
    
    
  level="debug" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_info" fileName="${log_path}/info.log" append="false">
    
    
    
    
 
    
    
    
    
  level="warn" onMatch="DENY" onMismatch="NEUTRAL" />
    
    
    
    
  level="info" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_warn" fileName="${log_path}/warn.log" append="false">
    
    
    
    
 
    
    
    
    
  level="error" onMatch="DENY" onMismatch="NEUTRAL" />
    
    
    
    
  level="warn" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_error" fileName="${log_path}/error.log" append="false">
    
    
    
    
 
    
    
    
    
  level="fatal" onMatch="DENY" onMismatch="NEUTRAL" />
    
    
    
    
  level="error" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="app_fatal" fileName="${log_path}/fatal.log" append="false">
    
    
    
    
 
    
    
    
    
  level="fatal" onMatch="ACCEPT" onMismatch="DENY" />
    
    
    
    
 
    
    
    
    
  pattern="${log_file}" />
    
    
    
    
 
    
    
    
    
  name="RollingFile" fileName="${log_path}/app.log" filePattern="${log_path}/app-%d{yyyy-MM-dd}-%i.log.gz">
    
    
    
    
  pattern="${log_file}"/>
    
    
    
    
  size="${every_file_size}"/>
    
    
    
    
 
    
    
    
    
  level="all" onMatch="ACCEPT" onMismatch="DENY"/>
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
 
    
    
    
    
  name="com.anxpp.demo" level="all" additivity="false">
    
    
    
    
  ref="Console" />
    
    
    
    
  ref="app_all" />
    
    
    
    
  ref="app_trace" />
    
    
    
    
  ref="app_debug" />
    
    
    
    
  ref="app_info" />
    
    
    
    
  ref="app_warn" />
    
    
    
    
  ref="app_error" />
    
    
    
    
  ref="app_fatal" />
    
    
    
    
  ref="RollingFile" />
    
    
    
    
 
    
    
    
    
 
    
    
    
    

   
   
   
   

   

4、log4j的使用

    log4j使用很简单：

    
    
    
    

     
     
     
     
public class DemoController {
     
     
     
     
 private static final Logger logger = LogManager.getLogger(DemoController.class);
     
     
     
     
 public String test(){
     
     
     
     
logger.trace("trace");
     
     
     
     
 return demoService.test();
     
     
     
     
 }
     
     
     
     
}
    
    
    
    

    可以看到，只需要调用一个很简单的方法即可。

    接下来我们在项目中使用以下代码测试(我们先将log4j2.xml文件中压缩的单个文件大小改为1M方便查看)：

    
    
    
    

     
     
     
     
 private static final Logger logger = LogManager.getLogger(DemoConreoller.class);
     
     
     
     
 @RequestMapping("/")
     
     
     
     
 public String index(){
     
     
     
     
logger.trace("index");
     
     
     
     
 return "index";
     
     
     
     
 }
     
     
     
     
 @RequestMapping("/test")
     
     
     
     
 @ResponseBody
     
     
     
     
 public String testRerutnString(){
     
     
     
     
 int i = 50000;
     
     
     
     
 while(i-->0){
     
     
     
     
logger.trace("trace" + i);
     
     
     
     
logger.debug("debug" + i);
     
     
     
     
logger.info("info" + i);
     
     
     
     
logger.warn("warn" + i);
     
     
     
     
logger.error("error" + i);
     
     
     
     
logger.fatal("fatal" + i);
     
     
     
     
 }
     
     
     
     
 return "Hello Word!";
     
     
     
     
 }
    
    
    
    

    运行项目后分别访问/和test：

    然后查看log日志文件：

    可以看到压缩文件大小为30K，我们设置的是1M，那就对了，log文件在压缩前是单个达到1M时就压缩，压缩完自然就变小了。

    再看看内容：

    内容如我们配置的一样，格式与控制台输出的稍微不同。

5、项目源码下载

    以下工程都是基于Spring4+Hibernate5集成Log4j2的。

    5.1、Maven工程下载：

    Spring4Hibernate5Log4j2MVC.7z(大小：12k)

    5.2、传统工程下载：

    Spring4Hibernate5SpringMVCLog4j2.7z(大小：15.4M)

    两个工程压缩包大小有如此的差别，归功于maven，将所有的jar包依赖放到了pom.xml文件中。