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"?>
<configuration monitorInterval="30">
...
</configuration>

    监控的时间间隔单位为秒,最小值是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在哪能够找到它:

<configuration … 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、基本配置介绍

    classes

    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的遗传效应了。

    目前支持的日志存放方式:
    123

    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<TRACE<DEBUG<INFO<WARN<ERROR<FATAL<OFF。

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

    2.2、部分输出方式介绍

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

      2.2.1、控制台
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <Console name="STDOUT" target="SYSTEM_OUT">
      <PatternLayout pattern="%m%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>
</Configuration>
      2.2.2、log文件
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <File name="MyFile" fileName="logs/app.log">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
    </File>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="MyFile"/>
    </Root>
  </Loggers>
</Configuration>
      2.2.3、jdbc记录到数据库

    (1)

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

    (2)

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

    

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"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

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

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

    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"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

    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"?>
<Configuration status="warn" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd}.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
      <DefaultRolloverStrategy>
        <Delete basePath="${baseDir}" maxDepth="2">
          <IfFileName glob="*/app-*.log.gz" />
          <IfLastModified age="60d" />
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

    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"?>
<Configuration status="warn" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
      </Policies>
      <DefaultRolloverStrategy max="100">
        <!--
        -->
        <Delete basePath="${baseDir}" maxDepth="2">
          <IfFileName glob="*/app-*.log.gz">
            <IfLastModified age="30d">
              <IfAny>
                <IfAccumulatedFileSize exceeds="100 GB" />
                <IfAccumulatedFileCount exceeds="10" />
              </IfAny>
            </IfLastModified>
          </IfFileName>
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

    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"?>
<Configuration status="trace" name="MyApp" packages="">
  <Properties>
    <Property name="baseDir">logs</Property>
  </Properties>
  <Appenders>
    <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
          filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyyMMdd}.log.gz">
      <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
      <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
      <DefaultRolloverStrategy>
        <Delete basePath="${baseDir}" maxDepth="2">
          <ScriptCondition>
            <Script 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;
              ]] >
            </Script>
          </ScriptCondition>
        </Delete>
      </DefaultRolloverStrategy>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

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

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

    3.1、添加依赖(jar包):

      3.1.1、传统工程方式

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

1

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

    2

    这里,我们需要这3个jar包:

        3

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

      3.1.2、Maven工程方式

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

      <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>2.5</version>
            <scope>runtime</scope>
        </dependency>

    3.2、配置

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

  <context-param>
        <param-name>isLog4jAutoInitializationDisabled</param-name>
        <param-value>false</param-value>
    </context-param>
    <context-param>
        <param-name>log4jConfiguration</param-name>
        <param-value>classpath:config/log4j2.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.apache.logging.log4j.web.Log4jServletContextListener</listener-class>
    </listener>
    <filter>
        <filter-name>log4jServletFilter</filter-name>
        <filter-class>org.apache.logging.log4j.web.Log4jServletFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>log4jServletFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>INCLUDE</dispatcher>
        <dispatcher>ERROR</dispatcher>
    </filter-mapping>

    log4jConfiguration为log4j2的配置文件位置。

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

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

   

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:

05

    然后查看log日志文件:

06

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

    再看看内容:

06

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

5、项目源码下载

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

    5.1、Maven工程下载:

    Spring4Hibernate5Log4j2MVC.7z(大小:12k)

    5.2、传统工程下载:

    Spring4Hibernate5SpringMVCLog4j2.7z(大小:15.4M)

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