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

版权声明:http://blog.csdn.net/anxpp https://blog.csdn.net/anxpp/article/details/50600055

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的支持。

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

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

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

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

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

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

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

  1. 19:08:07.056 TRACE com.test.TestService 19 retrieveMessage - entry
  2. 19:08:07.060 TRACE com.test.TestService 46 getKey - entry
      1.2.4、配置自动重新加载

    自动重新加载配置文件:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration monitorInterval="30">
  3. ...
  4. </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在哪能够找到它:

  1. <configuration … packages="de.grobmeier.examples.log4j2.plugins">

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

  1. @Plugin(name = "Sandbox", type = "Core", elementType = "appender")
  2. public class SandboxAppender extends AppenderBase {
  3.  private SandboxAppender(String name, Filter filter) {
  4.  super(name, filter, null);
  5.  }
  6.  public void append(LogEvent event) {
  7.  System.out.println(event.getMessage().getFormattedMessage());
  8.  }
  9.  @PluginFactory
  10.  public static SandboxAppender createAppender(
  11.  @PluginAttr("name") String name,
  12.  @PluginElement("filters") Filter filter) {
  13.  return new SandboxAppender(name, filter);
  14.  }
  15. }

    上面标有@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、控制台
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Appenders>
  4.  <Console name="STDOUT" target="SYSTEM_OUT">
  5.  <PatternLayout pattern="%m%n"/>
  6.  </Console>
  7.  </Appenders>
  8.  <Loggers>
  9.  <Root level="error">
  10.  <AppenderRef ref="STDOUT"/>
  11.  </Root>
  12.  </Loggers>
  13. </Configuration>
      2.2.2、log文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Appenders>
  4.  <File name="MyFile" fileName="logs/app.log">
  5.  <PatternLayout>
  6.  <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
  7.  </PatternLayout>
  8.  </File>
  9.  </Appenders>
  10.  <Loggers>
  11.  <Root level="error">
  12.  <AppenderRef ref="MyFile"/>
  13.  </Root>
  14.  </Loggers>
  15. </Configuration>
      2.2.3、jdbc记录到数据库

    (1)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="error">
  3.  <Appenders>
  4.  <JDBC name="databaseAppender" tableName="dbo.application_log">
  5.  <DataSource jndiName="java:/comp/env/jdbc/LoggingDataSource" />
  6.  <Column name="eventDate" isEventTimestamp="true" />
  7.  <Column name="level" pattern="%level" />
  8.  <Column name="logger" pattern="%logger" />
  9.  <Column name="message" pattern="%message" />
  10.  <Column name="exception" pattern="%ex{full}" />
  11.  </JDBC>
  12.  </Appenders>
  13.  <Loggers>
  14.  <Root level="warn">
  15.  <AppenderRef ref="databaseAppender"/>
  16.  </Root>
  17.  </Loggers>
  18. </Configuration>

    (2)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="error">
  3.  <Appenders>
  4.  <JDBC name="databaseAppender" tableName="LOGGING.APPLICATION_LOG">
  5.  <ConnectionFactory class="net.example.db.ConnectionFactory" method="getDatabaseConnection" />
  6.  <Column name="EVENT_ID" literal="LOGGING.APPLICATION_LOG_SEQUENCE.NEXTVAL" />
  7.  <Column name="EVENT_DATE" isEventTimestamp="true" />
  8.  <Column name="LEVEL" pattern="%level" />
  9.  <Column name="LOGGER" pattern="%logger" />
  10.  <Column name="MESSAGE" pattern="%message" />
  11.  <Column name="THROWABLE" pattern="%ex{full}" />
  12.  </JDBC>
  13.  </Appenders>
  14.  <Loggers>
  15.  <Root level="warn">
  16.  <AppenderRef ref="databaseAppender"/>
  17.  </Root>
  18.  </Loggers>
  19. </Configuration>

    

  1. package net.example.db;
  2. import java.sql.Connection;
  3. import java.sql.SQLException;
  4. import java.util.Properties;
  5. import javax.sql.DataSource;
  6. import org.apache.commons.dbcp.DriverManagerConnectionFactory;
  7. import org.apache.commons.dbcp.PoolableConnection;
  8. import org.apache.commons.dbcp.PoolableConnectionFactory;
  9. import org.apache.commons.dbcp.PoolingDataSource;
  10. import org.apache.commons.pool.impl.GenericObjectPool;
  11. public class ConnectionFactory {
  12.  private static interface Singleton {
  13.  final ConnectionFactory INSTANCE = new ConnectionFactory();
  14.  }
  15.  private final DataSource dataSource;
  16.  private ConnectionFactory() {
  17.  Properties properties = new Properties();
  18. properties.setProperty("user", "logging");
  19. properties.setProperty("password", "abc123"); // or get properties from some configuration file
  20.  GenericObjectPool<PoolableConnection> pool = new GenericObjectPool<PoolableConnection>();
  21.  DriverManagerConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
  22.  "jdbc:mysql://example.org:3306/exampleDb", properties
  23.  );
  24.  new PoolableConnectionFactory(
  25. connectionFactory, pool, null, "SELECT 1", 3, false, false, Connection.TRANSACTION_READ_COMMITTED
  26.  );
  27.  this.dataSource = new PoolingDataSource(pool);
  28.  }
  29.  public static Connection getDatabaseConnection() throws SQLException {
  30.  return Singleton.INSTANCE.dataSource.getConnection();
  31.  }
  32. }

    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:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Appenders>
  4.  <RollingFile name="RollingFile" fileName="logs/app.log"
  5.  filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
  6.  <PatternLayout>
  7.  <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
  8.  </PatternLayout>
  9.  <Policies>
  10.  <TimeBasedTriggeringPolicy />
  11.  <SizeBasedTriggeringPolicy size="250 MB"/>
  12.  </Policies>
  13.  </RollingFile>
  14.  </Appenders>
  15.  <Loggers>
  16.  <Root level="error">
  17.  <AppenderRef ref="RollingFile"/>
  18.  </Root>
  19.  </Loggers>
  20. </Configuration>

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Appenders>
  4.  <RollingFile name="RollingFile" fileName="logs/app.log"
  5.  filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
  6.  <PatternLayout>
  7.  <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
  8.  </PatternLayout>
  9.  <Policies>
  10.  <TimeBasedTriggeringPolicy />
  11.  <SizeBasedTriggeringPolicy size="250 MB"/>
  12.  </Policies>
  13.  <DefaultRolloverStrategy max="20"/>
  14.  </RollingFile>
  15.  </Appenders>
  16.  <Loggers>
  17.  <Root level="error">
  18.  <AppenderRef ref="RollingFile"/>
  19.  </Root>
  20.  </Loggers>
  21. </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:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Appenders>
  4.  <RollingFile name="RollingFile" fileName="logs/app.log"
  5.  filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
  6.  <PatternLayout>
  7.  <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
  8.  </PatternLayout>
  9.  <Policies>
  10.  <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
  11.  <SizeBasedTriggeringPolicy size="250 MB"/>
  12.  </Policies>
  13.  </RollingFile>
  14.  </Appenders>
  15.  <Loggers>
  16.  <Root level="error">
  17.  <AppenderRef ref="RollingFile"/>
  18.  </Root>
  19.  </Loggers>
  20. </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:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Properties>
  4.  <Property name="baseDir">logs</Property>
  5.  </Properties>
  6.  <Appenders>
  7.  <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
  8.  filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd}.log.gz">
  9.  <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
  10.  <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
  11.  <DefaultRolloverStrategy>
  12.  <Delete basePath="${baseDir}" maxDepth="2">
  13.  <IfFileName glob="*/app-*.log.gz" />
  14.  <IfLastModified age="60d" />
  15.  </Delete>
  16.  </DefaultRolloverStrategy>
  17.  </RollingFile>
  18.  </Appenders>
  19.  <Loggers>
  20.  <Root level="error">
  21.  <AppenderRef ref="RollingFile"/>
  22.  </Root>
  23.  </Loggers>
  24. </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:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="warn" name="MyApp" packages="">
  3.  <Properties>
  4.  <Property name="baseDir">logs</Property>
  5.  </Properties>
  6.  <Appenders>
  7.  <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
  8.  filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
  9.  <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
  10.  <Policies>
  11.  <TimeBasedTriggeringPolicy />
  12.  <SizeBasedTriggeringPolicy size="250 MB"/>
  13.  </Policies>
  14.  <DefaultRolloverStrategy max="100">
  15.  <!--
  16. -->
  17.  <Delete basePath="${baseDir}" maxDepth="2">
  18.  <IfFileName glob="*/app-*.log.gz">
  19.  <IfLastModified age="30d">
  20.  <IfAny>
  21.  <IfAccumulatedFileSize exceeds="100 GB" />
  22.  <IfAccumulatedFileCount exceeds="10" />
  23.  </IfAny>
  24.  </IfLastModified>
  25.  </IfFileName>
  26.  </Delete>
  27.  </DefaultRolloverStrategy>
  28.  </RollingFile>
  29.  </Appenders>
  30.  <Loggers>
  31.  <Root level="error">
  32.  <AppenderRef ref="RollingFile"/>
  33.  </Root>
  34.  </Loggers>
  35. </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:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <Configuration status="trace" name="MyApp" packages="">
  3.  <Properties>
  4.  <Property name="baseDir">logs</Property>
  5.  </Properties>
  6.  <Appenders>
  7.  <RollingFile name="RollingFile" fileName="${baseDir}/app.log"
  8.  filePattern="${baseDir}/$${date:yyyy-MM}/app-%d{yyyyMMdd}.log.gz">
  9.  <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
  10.  <CronTriggeringPolicy schedule="0 0 0 * * ?"/>
  11.  <DefaultRolloverStrategy>
  12.  <Delete basePath="${baseDir}" maxDepth="2">
  13.  <ScriptCondition>
  14.  <Script name="superstitious" language="groovy"><![CDATA[
  15.  import java.nio.file.*;
  16. def result = [];
  17. def pattern = ~/\d*\/app-(\d*)\.log\.gz/;
  18. pathList.each { pathWithAttributes ->
  19. def relative = basePath.relativize pathWithAttributes.path
  20. statusLogger.trace 'SCRIPT: relative path=' + relative + " (base=$basePath)";
  21.  // remove files dated Friday the 13th
  22. def matcher = pattern.matcher(relative.toString());
  23.  if (matcher.find()) {
  24. def dateString = matcher.group(1);
  25. def calendar = Date.parse("yyyyMMdd", dateString).toCalendar();
  26. def friday13th = calendar.get(Calendar.DAY_OF_MONTH) == 13 \
  27.  && calendar.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY;
  28.  if (friday13th) {
  29. result.add pathWithAttributes;
  30. statusLogger.trace 'SCRIPT: deleting path ' + pathWithAttributes;
  31.  }
  32.  }
  33.  }
  34. statusLogger.trace 'SCRIPT: returning ' + result;
  35. result;
  36.  ]] >
  37.  </Script>
  38.  </ScriptCondition>
  39.  </Delete>
  40.  </DefaultRolloverStrategy>
  41.  </RollingFile>
  42.  </Appenders>
  43.  <Loggers>
  44.  <Root level="error">
  45.  <AppenderRef ref="RollingFile"/>
  46.  </Root>
  47.  </Loggers>
  48. </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文件中如下添加依赖:

  1.  <dependency>
  2.  <groupId>org.apache.logging.log4j</groupId>
  3.  <artifactId>log4j-api</artifactId>
  4.  <version>2.5</version>
  5.  </dependency>
  6.  <dependency>
  7.  <groupId>org.apache.logging.log4j</groupId>
  8.  <artifactId>log4j-core</artifactId>
  9.  <version>2.5</version>
  10.  </dependency>
  11.  <dependency>
  12.  <groupId>org.apache.logging.log4j</groupId>
  13.  <artifactId>log4j-web</artifactId>
  14.  <version>2.5</version>
  15.  <scope>runtime</scope>
  16.  </dependency>

    3.2、配置

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

  1.  <context-param>
  2.  <param-name>isLog4jAutoInitializationDisabled</param-name>
  3.  <param-value>false</param-value>
  4.  </context-param>
  5.  <context-param>
  6.  <param-name>log4jConfiguration</param-name>
  7.  <param-value>classpath:config/log4j2.xml</param-value>
  8.  </context-param>
  9.  <listener>
  10.  <listener-class>org.apache.logging.log4j.web.Log4jServletContextListener</listener-class>
  11.  </listener>
  12.  <filter>
  13.  <filter-name>log4jServletFilter</filter-name>
  14.  <filter-class>org.apache.logging.log4j.web.Log4jServletFilter</filter-class>
  15.  </filter>
  16.  <filter-mapping>
  17.  <filter-name>log4jServletFilter</filter-name>
  18.  <url-pattern>/*</url-pattern>
  19.  <dispatcher>REQUEST</dispatcher>
  20.  <dispatcher>FORWARD</dispatcher>
  21.  <dispatcher>INCLUDE</dispatcher>
  22.  <dispatcher>ERROR</dispatcher>
  23.  </filter-mapping>

    log4jConfiguration为log4j2的配置文件位置。

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

  1. <configuration status="off" debug="off" monitorInterval="1800">
  2.  <Properties>
  3.  <Property name="log_path">d://logs</Property>
  4.  <property name="log_file">%d{yyyy-MM-dd HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n</property>
  5.  <property name="log_console">%d{HH:mm:ss.SSS z} %-5level %class{36}.%M()/%L - %msg%xEx%n</property>
  6.  <property name="every_file_size">10M</property>
  7.  </Properties>
  8.  <Appenders>
  9.  <Console name="Console" target="SYSTEM_OUT">
  10.  <ThresholdFilter level="all" onMatch="ACCEPT" onMismatch="DENY"/>
  11.  <PatternLayout pattern="${log_console}" />
  12.  </Console>
  13.  <File name="app_all" fileName="${log_path}/all.log" append="false">
  14.  <Filters>
  15.  <ThresholdFilter level="all" onMatch="ACCEPT" onMismatch="DENY" />
  16.  </Filters>
  17.  <PatternLayout pattern="${log_file}" />
  18.  </File>
  19.  <File name="app_trace" fileName="${log_path}/trace.log" append="false">
  20.  <Filters>
  21.  <ThresholdFilter level="debug" onMatch="DENY" onMismatch="NEUTRAL" />
  22.  <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY" />
  23.  </Filters>
  24.  <PatternLayout pattern="${log_file}" />
  25.  </File>
  26.  <File name="app_debug" fileName="${log_path}/debug.log" append="false">
  27.  <Filters>
  28.  <ThresholdFilter level="info" onMatch="DENY" onMismatch="NEUTRAL" />
  29.  <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
  30.  </Filters>
  31.  <PatternLayout pattern="${log_file}" />
  32.  </File>
  33.  <File name="app_info" fileName="${log_path}/info.log" append="false">
  34.  <Filters>
  35.  <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL" />
  36.  <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY" />
  37.  </Filters>
  38.  <PatternLayout pattern="${log_file}" />
  39.  </File>
  40.  <File name="app_warn" fileName="${log_path}/warn.log" append="false">
  41.  <Filters>
  42.  <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL" />
  43.  <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY" />
  44.  </Filters>
  45.  <PatternLayout pattern="${log_file}" />
  46.  </File>
  47.  <File name="app_error" fileName="${log_path}/error.log" append="false">
  48.  <Filters>
  49.  <ThresholdFilter level="fatal" onMatch="DENY" onMismatch="NEUTRAL" />
  50.  <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY" />
  51.  </Filters>
  52.  <PatternLayout pattern="${log_file}" />
  53.  </File>
  54.  <File name="app_fatal" fileName="${log_path}/fatal.log" append="false">
  55.  <Filters>
  56.  <ThresholdFilter level="fatal" onMatch="ACCEPT" onMismatch="DENY" />
  57.  </Filters>
  58.  <PatternLayout pattern="${log_file}" />
  59.  </File>
  60.  <RollingFile name="RollingFile" fileName="${log_path}/app.log" filePattern="${log_path}/app-%d{yyyy-MM-dd}-%i.log.gz">
  61.  <PatternLayout pattern="${log_file}"/>
  62.  <SizeBasedTriggeringPolicy size="${every_file_size}"/>
  63.  <Filters>
  64.  <ThresholdFilter level="all" onMatch="ACCEPT" onMismatch="DENY"/>
  65.  </Filters>
  66.  </RollingFile>
  67.  </Appenders>
  68.  <Loggers>
  69.  <Logger name="com.anxpp.demo" level="all" additivity="false">
  70.  <appender-ref ref="Console" />
  71.  <appender-ref ref="app_all" />
  72.  <appender-ref ref="app_trace" />
  73.  <appender-ref ref="app_debug" />
  74.  <appender-ref ref="app_info" />
  75.  <appender-ref ref="app_warn" />
  76.  <appender-ref ref="app_error" />
  77.  <appender-ref ref="app_fatal" />
  78.  <appender-ref ref="RollingFile" />
  79.  </Logger>
  80.  </Loggers>
  81. </configuration>

   

4、log4j的使用

    log4j使用很简单:

  1. public class DemoController {
  2.  private static final Logger logger = LogManager.getLogger(DemoController.class);
  3.  public String test(){
  4. logger.trace("trace");
  5.  return demoService.test();
  6.  }
  7. }

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

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

  1.  private static final Logger logger = LogManager.getLogger(DemoConreoller.class);
  2.  @RequestMapping("/")
  3.  public String index(){
  4. logger.trace("index");
  5.  return "index";
  6.  }
  7.  @RequestMapping("/test")
  8.  @ResponseBody
  9.  public String testRerutnString(){
  10.  int i = 50000;
  11.  while(i-->0){
  12. logger.trace("trace" + i);
  13. logger.debug("debug" + i);
  14. logger.info("info" + i);
  15. logger.warn("warn" + i);
  16. logger.error("error" + i);
  17. logger.fatal("fatal" + i);
  18.  }
  19.  return "Hello Word!";
  20.  }

    运行项目后分别访问/和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文件中。

阅读更多

没有更多推荐了,返回首页