Log4j2使用教程

最新推荐文章于 2023-04-13 18:04:20 发布

Herman-Hong

最新推荐文章于 2023-04-13 18:04:20 发布

阅读量2.3k

点赞数

分类专栏： java 架构 log4j2 log4j 2应用文章标签： log4j2

java 同时被 3 个专栏收录

135 篇文章 1 订阅

订阅专栏

架构

123 篇文章 0 订阅

订阅专栏

log4j2

6 篇文章 0 订阅

订阅专栏

http://www.cnblogs.com/leo-lsw/p/log4j2tutorial.html

Log4j 2的好处就不和大家说了，如果你搜了2，说明你对他已经有一定的了解，并且想用它，所以这里直接就上手了。

　　1. 去官方下载log4j 2，导入jar包，基本上你只需要导入下面两个jar包就可以了(xx是乱七八糟的版本号)：

　　　　log4j-core-xx.jar

　　　　log4j-api-xx.jar

　　2. 导入到你的项目中：这个就不说了。

　　3. 开始使用：

　　　　我们知道，要在某个类中使用log4j记录日志，只需要申明下面的成员变量（其实不一定要是成员变量，只是为了方便调用而已）

private static Logger logger = LogManager.getLogger(MyApp.class.getName());

　　　　这里getLogger有一个参数指定的是这个logger的名称，这个名称在配置文件里面可是有需要的，这个待会儿再说。

　　　　声明了Logger对象，我们就可以在代码中使用他了。

　　4. 日志的级别：

　　　　我们现在要调用logger的方法，不过在这个Logger对象中，有很多方法，所以要先了解log4j的日志级别，log4j规定了默认的几个级别：trace<debug<info<warn<error<fatal等。这里要说明一下：

　　　　1）级别之间是包含的关系，意思是如果你设置日志级别是trace，则大于等于这个级别的日志都会输出。

　　　　2）基本上默认的级别没多大区别，就是一个默认的设定。你可以通过它的API自己定义级别。你也可以随意调用这些方法，不过你要在配置文件里面好好处理了，否则就起不到日志的作用了，而且也不易读，相当于一个规范，你要完全定义一套也可以，不用没多大必要。

　　　　3）这不同的级别的含义大家都很容易理解，这里就简单介绍一下：

　　　　trace：是追踪，就是程序推进以下，你就可以写个trace输出，所以trace应该会特别多，不过没关系，我们可以设置最低日志级别不让他输出。

　　　　debug：调试么，我一般就只用这个作为最低级别，trace压根不用。是在没办法就用eclipse或者idea的debug功能就好了么。

　　　　info：输出一下你感兴趣的或者重要的信息，这个用的最多了。

　　　　warn：有些信息不是错误信息，但是也要给程序员的一些提示，类似于eclipse中代码的验证不是有error 和warn（不算错误但是也请注意，比如以下depressed的方法）。

　　　　error：错误信息。用的也比较多。

　　　　fatal：级别比较高了。重大错误，这种级别你可以直接停止程序了，是不应该出现的错误么！不用那么紧张，其实就是一个程度的问题。

　　5. 日志调用：

　　　　这里随便写个类，调用就是这么简单，log4j的核心在配置文件上。

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Hello {

    static Logger logger = LogManager.getLogger(Hello.class.getName());

    public boolean hello() {
        logger.entry();   //trace级别的信息，单独列出来是希望你在某个方法或者程序逻辑开始的时候调用，和logger.trace("entry")基本一个意思
        logger.error("Did it again!");   //error级别的信息，参数就是你输出的信息
        logger.info("我是info信息");    //info级别的信息
        logger.debug("我是debug信息");
        logger.warn("我是warn信息");
        logger.fatal("我是fatal信息");
        logger.log(Level.DEBUG, "我是debug信息");   //这个就是制定Level类型的调用：谁闲着没事调用这个，也不一定哦！
        logger.exit();    //和entry()对应的结束方法，和logger.trace("exit");一个意思
        return false;
    }
}

　　如果没有自定义配置文件，上面这个类在写一个main方法，控制台会输入下面的样子：

19:09:40.256 [main] ERROR cn.lsw.base.log4j2.Hello - Did it again!
19:09:40.260 [main] FATAL cn.lsw.base.log4j2.Hello - 我是fatal信息

　　看到没，只有>=ERROR的日志输出来了（这是因为Log4j有一个默认的配置，它的日志级别是ERROR，输出只有控制台）。如果我已经定义好了日志，我把日志级别改成了TRACE，输出会变成下面这样：　

19:11:36.941 TRACE cn.lsw.base.log4j2.Hello 12 hello - entry
19:11:36.951 ERROR cn.lsw.base.log4j2.Hello 13 hello - Did it again!
19:11:36.951 INFO  cn.lsw.base.log4j2.Hello 14 hello - 我是info信息
19:11:36.951 DEBUG cn.lsw.base.log4j2.Hello 15 hello - 我是debug信息
19:11:36.951 WARN  cn.lsw.base.log4j2.Hello 16 hello - 我是warn信息
19:11:36.952 FATAL cn.lsw.base.log4j2.Hello 17 hello - 我是fatal信息
19:11:36.952 DEBUG cn.lsw.base.log4j2.Hello 18 hello - 我是debug信息
19:11:36.952 TRACE cn.lsw.base.log4j2.Hello 19 hello - exit

　　所有的日志都打印出来了，大家可以对照上面的代码看一看。

　　6. 配置文件：

　　现在开始正题了。

　　本来以为Log4J 2应该有一个默认的配置文件的，不过好像没有找到，下面这个配置文件等同于缺省配置（from http://blog.csdn.net/welcome000yy/article/details/7962668）：

<?xml version="1.0" encoding="UTF-8"?>  
<configuration status="OFF">  
  <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="error">  
      <appender-ref ref="Console"/>  
    </root>  
  </loggers>  
</configuration>

　　而我们只要把configuration>loggers>root的level属性改为trace，就可以输出刚才写的所有信息了。相信用过Log4j的人对这个配置文件也不算陌生，Log4J传统的配置一直是.properties文件，键值对的形式，那种配置方式很不好看，但是基本上我们从这个配置文件也能看到Log4J 1的影子，无非是appender了，layout之类的，含义也基本一样的。

　　这里不准备仔细的讲配置文件，没什么必要，大家只要知道一些基本的配置就可以了。我这里写几个配置文件，并且给了一定的注释和讲解，基本上可以用了。

　第一个例子：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="OFF">
    <appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </appenders>
    <loggers>
        <!--我们只让这个logger输出trace信息，其他的都是error级别-->
        <!--
        additivity开启的话，由于这个logger也是满足root的，所以会被打印两遍。
        不过root logger 的level是error，为什么Bar 里面的trace信息也被打印两遍呢
        -->
        <logger name="cn.lsw.base.log4j2.Hello" level="trace" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <root level="error">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

　先简单介绍一下下面这个配置文件。

　　1）根节点configuration，然后有两个子节点：appenders和loggers（都是复数，意思就是可以定义很多个appender和logger了）（如果想详细的看一下这个xml的结构，可以去jar包下面去找xsd文件和dtd文件）

　　2）appenders：这个下面定义的是各个appender，就是输出了，有好多类别，这里也不多说（容易造成理解和解释上的压力，一开始也未必能听懂，等于白讲），先看这个例子，只有一个Console，这些节点可不是随便命名的，Console就是输出控制台的意思。然后就针对这个输出设置一些属性，这里设置了PatternLayout就是输出格式了，基本上是前面时间，线程，级别，logger名称，log信息等，差不多，可以自己去查他们的语法规则。

　　3）loggers下面会定义许多个logger，这些logger通过name进行区分，来对不同的logger配置不同的输出，方法是通过引用上面定义的logger，注意，appender-ref引用的值是上面每个appender的name，而不是节点名称。

　　这个例子为了说明什么呢？我们要说说这个logger的name（名称）了（前面有提到）。

　　7. name的机制：(可以参考： http://logging.apache.org/log4j/2.x/manual/architecture.html)

　　　我们这里看到了配置文件里面是name很重要，没错，这个name可不能随便起（其实可以随便起）。这个机制意思很简单。就是类似于java package一样，比如我们的一个包：cn.lsw.base.log4j2。而且，可以发现我们前面生成Logger对象的时候，命名都是通过 Hello.class.getName(); 这样的方法，为什么要这样呢？很简单，因为有所谓的Logger 继承的问题。比如如果你给cn.lsw.base定义了一个logger，那么他也适用于cn.lsw.base.lgo4j2这个logger。名称的继承是通过点（.）分隔的。然后你可以猜测上面loggers里面有一个子节点不是logger而是root，而且这个root没有name属性。这个root相当于根节点。你所有的logger都适用与这个logger，所以，即使你在很多类里面通过类名.class.getName() 得到很多的logger，而且没有在配置文件的loggers下面做配置，他们也都能够输出，因为他们都继承了root的log配置。

　　我们上面的这个配置文件里面还定义了一个logger，他的名称是 cn.lsw.base.log4j2.Hello ，这个名称其实就是通过前面的Hello.class.getName(); 得到的，我们为了给他单独做配置，这里就生成对于这个类的logger，上面的配置基本的意思是只有cn.lsw.base.log4j2.Hello 这个logger输出trace信息，也就是他的日志级别是trace，其他的logger则继承root的日志配置，日志级别是error，只能打印出ERROR及以上级别的日志。如果这里logger 的name属性改成cn.lsw.base，则这个包下面的所有logger都会继承这个log配置（这里的包是log4j的logger name的“包”的含义，不是java的包，你非要给Hello生成一个名称为“myhello”的logger，他也就没法继承cn.lsw.base这个配置了。

　　那有人就要问了，他不是也应该继承了root的配置了么，那么会不会输出两遍呢？我们在配置文件中给了解释，如果你设置了additivity="false"，就不会输出两遍，否则，看下面的输出：

　　这里要在加入一个类做对比：　

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Test {


    private static Logger logger = LogManager.getLogger(Test.class.getName());

    public static void main(String[] args) {

        logger.trace("开始程序.");
        Hello hello= new Hello();
//        for (int i = 0; i < 10000;i++){
            if (!hello.hello()) {
                logger.error("hello");
            }
//        }
        logger.trace("退出程序.");
    }
}

　　这里先把配置文件改一下方便对照，一个是刚才第一个logger的名称还是cn.lsw.base.log4j2.Hello，additivity去掉或改为true（因为默认是true，所以可以去掉），第二是把root的level改为info方便观察。　

　　然后运行Test，看控制台的日志输出：

2013-12-20 19:59:42.538 [main] INFO  cn.lsw.base.log4j2.Test - test
2013-12-20 19:59:42.541 [main] TRACE cn.lsw.base.log4j2.Hello - entry
2013-12-20 19:59:42.541 [main] TRACE cn.lsw.base.log4j2.Hello - entry
2013-12-20 19:59:42.542 [main] ERROR cn.lsw.base.log4j2.Hello - Did it again!
2013-12-20 19:59:42.542 [main] ERROR cn.lsw.base.log4j2.Hello - Did it again!
2013-12-20 19:59:42.542 [main] INFO  cn.lsw.base.log4j2.Hello - 我是info信息
2013-12-20 19:59:42.542 [main] INFO  cn.lsw.base.log4j2.Hello - 我是info信息
2013-12-20 19:59:42.542 [main] DEBUG cn.lsw.base.log4j2.Hello - 我是debug信息
2013-12-20 19:59:42.542 [main] DEBUG cn.lsw.base.log4j2.Hello - 我是debug信息
2013-12-20 19:59:42.542 [main] WARN  cn.lsw.base.log4j2.Hello - 我是warn信息
2013-12-20 19:59:42.542 [main] WARN  cn.lsw.base.log4j2.Hello - 我是warn信息
2013-12-20 19:59:42.542 [main] FATAL cn.lsw.base.log4j2.Hello - 我是fatal信息
2013-12-20 19:59:42.542 [main] FATAL cn.lsw.base.log4j2.Hello - 我是fatal信息
2013-12-20 19:59:42.542 [main] DEBUG cn.lsw.base.log4j2.Hello - 我是debug信息
2013-12-20 19:59:42.542 [main] DEBUG cn.lsw.base.log4j2.Hello - 我是debug信息
2013-12-20 19:59:42.543 [main] TRACE cn.lsw.base.log4j2.Hello - exit
2013-12-20 19:59:42.543 [main] TRACE cn.lsw.base.log4j2.Hello - exit
2013-12-20 19:59:42.543 [main] ERROR cn.lsw.base.log4j2.Test - hello

　　可以看出，Test的trace日志没有输出，因为他继承了root的日志配置，只输出info即以上级别的日志。Hello 输出了trace及以上级别的日志，但是每个都输出了两遍。你可以试一下，把第一个logger的level该为error，那么error以上的级别也是输出两遍。这时候，只要加上additivity为false就可以避免这个问题了。

　　当然，你可以为每个logger 都在配置文件下面做不同的配置，也可以通过继承机制，对不同包下面的日志做不同的配置。因为loggers下面可以写很多歌logger。

　　下面在看一个稍微复杂的例子：

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

<configuration status="error">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY"/>
            <!--这个都知道是输出日志的格式-->
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </Console>
        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
        <File name="log" fileName="log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!--这个会打印出所有的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
        </RollingFile>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <!--建立一个默认的root的logger-->
        <root level="trace">
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="Console"/>
        </root>

    </loggers>
</configuration>

　　说复杂，其实也不复杂，这一个例子主要是为了讲一下appenders。

　　这里定义了三个appender，Console，File，RollingFile，看意思基本也明白，第二个是写入文件，第三个是“循环”的日志文件，意思是日志文件大于阀值的时候，就开始写一个新的日志文件。

　　这里我们的配置文件里面的注释算比较详细的了。所以就大家自己看了。有一个比较有意思的是ThresholdFilter ，一个过滤器，其实每个appender可以定义很多个filter，这个功能很有用。如果你要选择控制台只能输出ERROR以上的类别，你就用ThresholdFilter，把level设置成ERROR，onMatch="ACCEPT" onMismatch="DENY" 的意思是匹配就接受，否则直接拒绝，当然有其他选择了，比如交给其他的过滤器去处理了之类的，详情大家自己去琢磨吧。

　　为什么要加一个这样的配置文件呢？其实这个配置文件我感觉挺好的，他的实用性就在下面：

　　8. 一个实用的配置文件：

　　我们用日志一方面是为了记录程序运行的信息，在出错的时候排查之类的，有时候调试的时候也喜欢用日志。所以，日志如果记录的很乱的话，看起来也不方便。所以我可能有下面一些需求：

　　1）我正在调试某个类，所以，我不想让其他的类或者包的日志输出，否则会很多内容，所以，你可以修改上面root的级别为最高（或者谨慎起见就用ERROR），然后，加一个针对该类的logger配置，比如第一个配置文件中的设置，把他的level设置trace或者debug之类的，然后我们给一个appender-ref是定义的File那个appender（共三个appender，还记得吗），这个appender的好处是有一个append为false的属性，这样，每次运行都会清空上次的日志，这样就不会因为一直在调试而增加这个文件的内容，查起来也方便，这个和输出到控制台就一个效果了。

　　2）我已经基本上部署好程序了，然后我要长时间运行了。我需要记录下面几种日志，第一，控制台输出所有的error级别以上的信息。第二，我要有一个文件输出是所有的debug或者info以上的信息，类似做程序记录什么的。第三，我要单独为ERROR以上的信息输出到单独的文件，如果出了错，只查这个配置文件就好了，不会去处理太多的日志，看起来头都大了。怎么做呢，很简单。

　　>首先，在appenders下面加一个Console类型的appender，通过加一个ThresholdFilter设置level为error。（直接在配置文件的Console这个appender中修改）

　　>其次，增加一个File类型的appender（也可以是RollingFile或者其他文件输出类型），然后通过设置ThresholdFilter的level为error，设置成File好在，你的error日志应该不会那么多，不需要有多个error级别日志文件的存在，否则你的程序基本上可以重写了。

　　这里可以添加一个appender，内容如下：

  <File name="ERROR" fileName="logs/error.log">
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="%d{yyyy.MM.dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

　　并在loggers中的某个logger(如root）中引用（root节点加入这一行作为子节点）。　

 <appender-ref ref="ERROR" />

　　>然后，增加一个RollingFile的appender，设置基本上同上面的那个配置文件。

　　>最后，在logger中进行相应的配置。不过如果你的logger中也有日志级别的配置，如果级别都在error以上，你的appender里面也就不会输出error一下的信息了。

　　还记得上面的Test类里面有一个被注释掉的for循环么？这个是为了做配置文件中RollingFile那个appender的配置的，取消注释，运行商一次或几次，看你的输出配置文件的地方，他是怎么“RollingFile”的，这里给个我测试的截图：（这里你可以把 <SizeBasedTriggeringPolicy size="50MB"/>这里的size改成2MB，要生成50MB的日志还是比较慢的。为了方便观察么！然后把Console的ThresholdFilter的level设置成error这样的较高级别，不然控制台输出东西太多了）

　　第一部分（图中标识为1），是我加入的jar包；

　　第二部分是File这个appender生成的日志文件，你会发现你运行很多次，这个文件中的日志是被覆盖的。

　　第三部分是RollingFile 这个appender生成的配置文件，可以发现，默认建立的是app.log这个日志，每次超过2MB的时候，就会生成对应年-月的文件夹，和制定命名格式的log文件，而且是压缩成gz格式文件，打开资源管理器发现这个文件只有11KB，解压后就是2MB。

　　最后，希望这个教程能够帮到大家！

http://www.cnblogs.com/elaron/archive/2013/02/17/2914633.html

前言

　　Appender按网络释义，有“输出目的地”之意。官网给出的定义是：“Appenders are responsible for delivering LogEvents to their destination.”。Log4j2为使用者提供了13种非常实用的Appenders，使用者可用方便的调用这13种Appender来控制日志的输出。

摘要

　　Log4j2的Appenders充分考虑了日志事件的输出、包装以及过滤转发的可能，包括最基本的输出到本地文件、输出到远程主机，对文件进行封装、注入，并且还能按照日志文件的时间点、文件大小等条件进行自动封存。例如，想要将几个不同源的日志汇集到一起，可以用FlumeAppender；想要在LogEvent中注入信息，可以用RewriteAppender；想要让系统按照设定的时间间隔自动封存日志信息，可以用RollingFileAppender（每隔一定时间自动保存一份新增的日志文件，并按照时间戳等指定格式命名）；当产生安全级别达ERROR或FATAL的LogEvent时，给维护人员发送邮件可用SMTPAppender；希望将日志信息写到远程主机的，可用SocketAppender；希望能够按照RFC5424格式向远程主机发送日志信息，可用SyslogAppender。等等。

下面将按照如下顺序依次介绍每个Appender的作用及重要参数，并附上完整参数地址及官网配置示例地址。

1、FileAppender 　　普通地输出到本地文件

2、FlumeAppender　　将几个不同源的日志汇集、集中到一处。

3、JMSQueueAppender VS. JMSTopicAppender　　与JMS相关的日志输出

4、RewriteAppender 　　对日志事件进行掩码或注入信息

5、RollingFileAppender　　对日志文件进行封存（详细）

6、RoutingAppender　　在输出地之间进行筛选路由

7、SMTPAppender　　将LogEvent发送到指定邮件列表

8、SocketAppender　　将LogEvent以普通格式发送到远程主机

9、SyslogAppender　　将LogEvent以RFC 5424格式发送到远程主机

10、AsynchAppender 　　将一个LogEvent异步地写入多个不同输出地

11、ConsoleAppender　　将LogEvent输出到命令行

12、FailoverAppender　　维护一个队列，系统将尝试向队列中的Appender依次输出LogEvent，直到有一个成功为止

正文：

1、FileAppender

FileAppender用于将LogEvent写入到一个文件中，该文件由fileName参数指定。有几个重要的参数：

① fileName，String，指定写入的log文件的名称。

② append，boolean，指定是否是追加写入（append=true，默认情况），还是覆盖写入（append=false）。

③ bufferedIO，boolean，是否对数据进行缓冲到缓冲区满后再写入。测试显示，即使在启用immediateFlush的情况下，设置bufferedIO=true也能提高性能。

④ locking，boolean，是否对文件上锁，当有多个线程可能同时写该文件时需要考虑上锁（在《异常处理反模式》中就提到要把在一起的日志输出语句写到一句，而不是拆成几句来避免并发线程导致的日志语句之间的错位）。但对文件上锁会影响系统的性能，所以需要谨慎使用。默认值是false。

【完整的参数设置和官方配置示例】

2、FlumeAppender

　　FlumeAppender是一个可选的组件，它并不包含在core jar中，若要使用，需要额外加入log4j-flume-ng-2.0-beta4.jar包。FlumeAppender是配合Apache Flume来使用的。Apache Flume是一个能有效地将不同地方的大量日志数据收集、聚会到一起的一个系统。详细信息参见【Apache Flume】

几个比较重要的参数：

① agents，Agent[]，用来维护一个将接收log event的数组，如果数组中agent的数量大于1，那么将把第一个agent视为primary agent，剩下的为备选agent。当第一个agent无法连接时，将把log event发送给备选agent。

② batchSize，integer，一次给agent发送的log event的个数。

③ compress，boolean，当设置为true时，发送的message将使用gzip进行压缩。

【完整的参数设置和官方配置示例】

3、JMSQueueAppender VS. JMSTopicAppender

　　JMSQueueAppender的作用是将格式化的log event发送到JMSQueue上，同样的，JMSTopicAppender的作用是将格式化的log event发送到JMSTopic上。JMSQueue和JMSTopic的区别是，JMSQueue只将一个message发送给一个consumer，而JMSTopic是将一个message发布（publish）给所有订阅了这个message的订阅者（subscribe）。更详细的两者间的区别可以【戳这里】

几个重要的参数：

JMSQueueAppender：

① queueBindingName，String，用来定位queue。

② factoryBindingName，String，用来定位产生上下文信息的QueueConnectionFactory。

【完整的参数设置和官方配置示例】

JMSTopicAppender：

① topicBindingName，String，用来定位topic。

② factoryBindingName，String，用来定位产生上下文信息的QueueConnectionFactory。

【完整的参数设置和官方配置示例】

4、RewriteAppender

　　RewriteAppender可以让符合筛选条件的log event在被其他appender输出前被加工一下，比如对message中的密码进行掩码，或者向message中注入信息等。RewriteAppender需要一个RewritePolicy来指定重写的规则。

几个重要的参数：

① appender-ref，String，指定被重写后的log event将发往哪个appender。

② rewritePolicy，RewritePolciy，用来描述重写log event的规则。

RewritePolicy：

RewritePolicy是一个接口，有一个需要实现的方法名为rewrite，该方法接收一个log event对象作为参数，然后经过函数处理后返回该log event或新建一个log event返回。

Log4j2中已实现的两种RewritePolicy有MapRewritePolicy和PropertiesRewritePolicy。

【完整的参数设置、已实现的RewritePolicy和官方配置示例】

5、RollingFileAppender

　　RollingFileAppender是一个非常有意思的输出器。它将log信息写入一个文件后，会判断是否满足封存文件的要求，若满足，则除非封存文件的动作。RollingFileAppender需要TriggeringPolicy来指定触发封存的条件，另外还需要RolloverStrategy来告诉输出器如何封存文件。

Log4j2中已提供的TriggeringPolicy有如下四种：

① CompositeTriggeringPolicy

复合型触发策略。即将多个触发条件逻辑或到一起，只要其中一个条件满足，则触发封存动作。

② OnStartup Triggering Policy

这一触发策略不需要参数设置，它会自行判断log文件的创建时间和JVM的启动时间。若log文件的创建时间早于JVM的启动时间，则将原来的log文件封存，然后创建一个新的空白log文件。

③ SizeBased Triggering Policy

这一触发策略基于对log文件大小的判断。当log文件大于设定的阈值时，将触发封存动作。可设定的log文件大小的单位有bytes、KB、MB或GB。

④ TimeBased Triggering Policy

基于时间的触发策略。该策略主要是完成周期性的log文件封存工作。有两个参数：

interval，integer型，指定两次封存动作之间的时间间隔。

modulate，boolean型，说明是否对封存时间进行调制。若modulate=true，则封存时间将以0点为边界进行偏移计算。比如，modulate=true，interval=4hours，那么假设上次封存日志的时间为03:00，则下次封存日志的时间为04:00，之后的封存时间依次为08:00，12:00，16:00，。。。

Log4j2中实现的RolloverStrategy为Default Rollover Strategy，它有三个参数可以设置，分别为：

fileIndex，String，有两个选择“max”或“min”。设置为“max”意味着将最新的日志信息封存在序号较大的封存文件中。“min”则相反。

min，integer，封存文件的序号的起始值。

max，integer，封存文件的序号的最大值。（超过最大值时，将有文件被删除）

相当于min和max两个参数设置了一个保存窗口，超出这个窗口的日志文件将会被删除。

【完整的参数设置、TriggeringPolicy和RolloverStrategy的用法示例】

6、RoutingAppender

　　通过路由规则来评价一个log event后，决定它下一个被发往的appender。RoutingAppender有一个重要的参数名为routes，是Routes型数据，用来描述该appender的路由规则。

【完整的参数设置和官方配置示例】

7、SMTPAppender

　　SMTPAppender主要用来给指定的E-mail发送log event（这种情况一般用在event的安全级别超过ERROR或FATAL时，event的安全分级可以参考【此文】之日志记录小节）。SMTPAppender有很多重要的参数以完成log event发送到指定E-mail。

① bcc，String，由逗号分隔的几个盲抄送地址。（盲抄送就是说收件人的地址不会显示在邮件信息中）

② cc，String，由逗号分隔的几个明抄送地址。（明抄送就是说收件人的地址将显示在邮件信息中）

③ bufferSize，integer，信中所能包含的最大log event的数量。

④ from，String，发件人的地址。

⑤ layout，Layout，log event的布局格式。默认为SerializedLayout。

⑥ replyTo，String，回信的地址。

⑦ smtpHost，String，要发送到的SMTP的主机名。（此参数是必需的）

⑧ smtpPassword，String，通过SMTP服务器所需的密码。

⑨ smtpPort，integer，SMTP服务的端口号。

⑩ smtpProtocol，String，使用的协议。默认为"smtp"。

其他还有smtpUsername（通过SMTP server所需的用户名），to（接收者的邮件地址）等。

【完整的参数介绍和官方配置示例】

8、SocketAppender

将log event输出到一个远程服务器上（需指定服务器名和端口号），数据可以以任意指定的格式经由TCP或UDP协议发送。

SocketAppender中比较重要的参数有：

① host，String，指定服务器的主机名。（必需）

② immediateFlush，boolean，是否立即flush，还是等待缓存到一定大小后在flush。

③ layout，Layout，log event输出的格式。

④ port，integer，远程服务器坚挺log event的应用的端口号。

⑤ protocol，String，发送log event所使用的协议，"TCP" 或"UDP"。

⑥ reconnectionDelay，integer，当连接断开时，延迟等待的ms数。

【完整的参数介绍和官方配置示例】

9、SyslogAppender

SyslogAppender跟SocketAppender一样，是将log event发送到远程服务器上，但是使用的是BSD Syslog格式。关于Syslog格式可以【戳这里】

【完整的参数介绍和官方配置示例】

10、AsynchAppender 　　

　　将一个LogEvent异步地写入多个不同输出地。在AsynchAppender中有一个参数，名为“appender-ref”，用来指定要发送到的appender的名称。AsynchAppender维护了一个队列，队列中存放了需要异步发送的LogEvent，队列中LogEvent的个数可以通过“bufferSize”参数来指定。另外，还有一个“blocking”参数来指定是否对AsynchAppender的LogEvent队列上锁，如果blocking=true，那么在队列满员的情况下，新到达的LogEvent将等待，直到有空位。若blocking=false，那么在队列满员的情况下，将把新到的LogEvent转到error appender。

【完整的参数介绍和官方配置示例】

11、ConsoleAppender　　

　　将LogEvent输出到命令行。有两个比较有意思的参数，一个是layout，用来指定输出字串的格式（format）；另一个是target，用来指定输出的是 "SYSTEM_OUT" 还是 "SYSTEM_ERR"，默认情况下是"SYSTEM_ERR"。

【完整的参数介绍和官方配置示例】

12、FailoverAppender　　

维护一个failover appenders队列，系统先尝试一个主appender（primary appender），若不成功，则尝试failover队列中的Appenders，直到有一个成功为止，或都不成功。比较重要的参数有：

primary（String型）：用来指定主appender的名称。

failovers（String[]型）：一个appender数组，指定的备选的其他appenders。

retryInterval（integer型）：用来设定隔多少秒重新尝试主appender，默认为60秒。

【完整的参数介绍和官方配置示例】

参考资料：

1、Log4j2 Appenders 官网介绍