Appender负责将LogEvents传递到目的地。 每个Appender都必须实现Appender接口。 大多数Appender将扩展AbstractAppender，它增加了Lifecycle和Filterable支持。 Lifecycle允许组件在配置完成后完成初始化并在关闭期间执行清理。 Filterable允许组件加入过滤器，在事件处理期间对其进行过滤。

Appender通常只负责将事件数据写入目标地址。在大多数情况下，他们将格式化事件的责任委托给layout。一些appenders包装其他appenders，以便他们可以修改LogEvent，处理Appender中的失败，根据高级过滤条件将事件路由到从属Appender或提供类似的功能。

Appender总是有一个名称，以便可以在Loggers中引用它们。

AsyncAppender

AsyncAppender接受对其他Appender的引用，并使LogEvents在单独的Thread上写入它们。 请注意，写入这些Appender时的异常将从应用程序中隐藏。 应该在它引用的appender之后配置AsyncAppender以允许它正确关闭。

默认情况下，AsyncAppender使用java.util.concurrent.ArrayBlockingQueue，它不需要任何外部库。 请注意，多线程应用程序在使用此appender时应小心：阻塞队列容易受到锁争用的影响，并且我们的测试表明，当更多线程同时记录时性能可能会变差。 考虑使用无锁异步记录器以获得最佳性能。

AsyncAppender参数

即使底层appender无法跟上日志记录速率并且队列正在填满，也有一些系统属性可用于维护应用程序吞吐量。 请参阅系统属性log4j2.AsyncQueueFullPolicy和log4j2.DiscardThreshold的详细信息。

典型的AsyncAppender配置可能如下所示：

<?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>
    <Async name="Async">
      <AppenderRef ref="MyFile"/>
    </Async>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="Async"/>
    </Root>
  </Loggers>
</Configuration>

从Log4j 2.7开始，可以使用BlockingQueueFactory插件指定BlockingQueue或TransferQueue的自定义实现。 要覆盖默认的BlockingQueueFactory，请在元素中指定插件，如下所示：

<Configuration name="LinkedTransferQueueExample">
  <Appenders>
    <List name="List"/>
    <Async name="Async" bufferSize="262144">
      <AppenderRef ref="List"/>
      <LinkedTransferQueue/>
    </Async>
  </Appenders>
  <Loggers>
    <Root>
      <AppenderRef ref="Async"/>
    </Root>
  </Loggers>
</Configuration>

Log4j附带以下实现：
BlockingQueueFactory实现

CassandraAppender

CassandraAppender将其输出写入Apache Cassandra数据库。 必须提前配置密钥空间和表，并且该表的列将映射到配置文件中。

每列可以指定StringLayout（例如，PatternLayout）和可选的转换类型，或者只指定org.apache.logging.log4j.spi.ThreadContextMap或org.apache.logging.log4j.spi.ThreadContextStack的转换类型 将MDC或NDC分别存储在map或列表列中。与java.util.Date兼容的转换类型将使用转换为该类型的日志事件时间戳（例如，使用java.util.Date填充Cassandra中的时间戳列类型）

CassandraAppender参数

以下是CassandraAppender配置示例：

<Configuration name="CassandraAppenderTest">
  <Appenders>
    <Cassandra name="Cassandra" clusterName="Test Cluster" keyspace="test" table="logs" bufferSize="10" batched="true">
      <SocketAddress host="localhost" port="9042"/>
      <ColumnMapping name="id" pattern="%uuid{TIME}" type="java.util.UUID"/>
      <ColumnMapping name="timeid" literal="now()"/>
      <ColumnMapping name="message" pattern="%message"/>
      <ColumnMapping name="level" pattern="%level"/>
      <ColumnMapping name="marker" pattern="%marker"/>
      <ColumnMapping name="logger" pattern="%logger"/>
      <ColumnMapping name="timestamp" type="java.util.Date"/>
      <ColumnMapping name="mdc" type="org.apache.logging.log4j.spi.ThreadContextMap"/>
      <ColumnMapping name="ndc" type="org.apache.logging.log4j.spi.ThreadContextStack"/>
    </Cassandra>
  </Appenders>
  <Loggers>
    <Logger name="org.apache.logging.log4j.cassandra" level="DEBUG">
      <AppenderRef ref="Cassandra"/>
    </Logger>
    <Root level="ERROR"/>
  </Loggers>
</Configuration>

此示例配置使用以下建表脚本：

CREATE TABLE logs (
    id timeuuid PRIMARY KEY,
    timeid timeuuid,
    message text,
    level text,
    marker text,
    logger text,
    timestamp timestamp,
    mdc map<text,text>,
    ndc list<text>
);

ConsoleAppender

正如人们所预料的那样，ConsoleAppender将其输出写入System.out或System.err，默认使用System.out。 必须提供Layout以格式化LogEvent。

ConsoleAppender参数

典型的 Console 配置如下所示：

<?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>

FailoverAppender

FailoverAppender包装了一组appender。 如果主Appender失败，将按顺序尝试辅助appender，直到一个成功或没有更多辅助appender可以尝试。

FailoverAppender参数

Failover 配置如下所示

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log" filePattern="logs/app-%d{MM-dd-yyyy}.log.gz"
                 ignoreExceptions="false">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <TimeBasedTriggeringPolicy />
    </RollingFile>
    <Console name="STDOUT" target="SYSTEM_OUT" ignoreExceptions="false">
      <PatternLayout pattern="%m%n"/>
    </Console>
    <Failover name="Failover" primary="RollingFile">
      <Failovers>
        <AppenderRef ref="Console"/>
      </Failovers>
    </Failover>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="Failover"/>
    </Root>
  </Loggers>
</Configuration>

FileAppender

FileAppender是一个OutputStreamAppender，它写入fileName参数中指定的文件。 FileAppender使用FileManager（扩展OutputStreamManager）来实际执行文件I / O. 虽然无法共享来自不同配置的FileAppender，但是如果可以访问Manager，则可以使用FileManagers。 例如，servlet容器中的两个Web应用程序可以拥有自己的配置，并且如果Log4j位于两个共用的ClassLoader中，则可以安全地写入同一文件。

FileAppender参数

这是一个示例 File配置：

<?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>

FlumeAppender

这是一个单独的jar中提供的可选组件。

Apache Flume是一个分布式，可靠且可用的系统，用于有效地从许多不同的源收集，聚合和移动大量日志数据到集中式数据存储。 FlumeAppender接收LogEvents并将它们作为序列化的Avro事件发送到Flume代理以供使用。

Flume Appender支持三种操作模式。

1. 它可以充当远程Flume客户端，通过Avro将Flume事件发送到配置了Avro Source的Flume Agent。
2. 它可以作为嵌入式Flume Agent，Flume事件直接传递到Flume进行处理。
3. 它可以将事件持久保存到本地BerkeleyDB数据存储，然后异步将事件发送到Flume，类似于嵌入式Flume Agent，但没有大多数Flume依赖项。

用作嵌入式代理将导致消息直接传递到Flume Channel，然后控件将立即返回给应用程序。 与远程代理的所有交互都将异步进行。 将“type”属性设置为“Embedded”将强制使用嵌入式代理。 此外，在appender配置中配置代理属性也将导致使用嵌入式代理。

FlumeAppender参数

使用主代理和辅助代理配置的FlumeAppender配置示例，压缩消息体，并使用RFC5424Layout格式化消息：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <Flume name="eventLogger" compress="true">
      <Agent host="192.168.10.101" port="8800"/>
      <Agent host="192.168.10.102" port="8800"/>
      <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
    </Flume>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="eventLogger"/>
    </Root>
  </Loggers>
</Configuration>

使用主代理和辅助代理配置的FlumeAppender配置示例，压缩消息，使用RFC5424Layout格式化消息并将事件传递给嵌入式Flume代理。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp" packages="">
  <Appenders>
    <Flume name="eventLogger" compress="true" type="Embedded">
      <Agent host="192.168.10.101" port="8800"/>
      <Agent host="192.168.10.102" port="8800"/>
      <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
    </Flume>
    <Console name="STDOUT">
      <PatternLayout pattern="%d [%p] %c %m%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Logger name="EventLogger" level="info">
      <AppenderRef ref="eventLogger"/>
    </Logger>
    <Root level="warn">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>
</Configuration>

使用Flume配置属性配置主代理和辅助代理的FlumeAppender配置示例，压缩消息体，使用RFC5424Layout格式化消息并将事件传递给嵌入式Flume代理。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" name="MyApp" packages="">
  <Appenders>
    <Flume name="eventLogger" compress="true" type="Embedded">
      <Property name="channels">file</Property>
      <Property name="channels.file.type">file</Property>
      <Property name="channels.file.checkpointDir">target/file-channel/checkpoint</Property>
      <Property name="channels.file.dataDirs">target/file-channel/data</Property>
      <Property name="sinks">agent1 agent2</Property>
      <Property name="sinks.agent1.channel">file</Property>
      <Property name="sinks.agent1.type">avro</Property>
      <Property name="sinks.agent1.hostname">192.168.10.101</Property>
      <Property name="sinks.agent1.port">8800</Property>
      <Property name="sinks.agent1.batch-size">100</Property>
      <Property name="sinks.agent2.channel">file</Property>
      <Property name="sinks.agent2.type">avro</Property>
      <Property name="sinks.agent2.hostname">192.168.10.102</Property>
      <Property name="sinks.agent2.port">8800</Property>
      <Property name="sinks.agent2.batch-size">100</Property>
      <Property name="sinkgroups">group1</Property>
      <Property name="sinkgroups.group1.sinks">agent1 agent2</Property>
      <Property name="sinkgroups.group1.processor.type">failover</Property>
      <Property name="sinkgroups.group1.processor.priority.agent1">10</Property>
      <Property name="sinkgroups.group1.processor.priority.agent2">5</Property>
      <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
    </Flume>
    <Console name="STDOUT">
      <PatternLayout pattern="%d [%p] %c %m%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Logger name="EventLogger" level="info">
      <AppenderRef ref="eventLogger"/>
    </Logger>
    <Root level="warn">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>
</Configuration

JDBCAppender

JDBCAppender使用标准JDBC将日志事件写入关系数据库表。 可以将其配置为使用JNDI DataSource或自定义工厂方法获取JDBC连接。 无论采用哪种方法，都必须由连接池支持。 否则，记录性能将受到很大影响。 如果配置的JDBC驱动程序支持批处理语句，并且bufferSize配置为正数，则将批处理日志事件。 请注意，从Log4j 2.8开始，有两种方法可以将日志事件配置为列映射：原始的ColumnConfig样式只允许字符串和时间戳，而新的ColumnMapping插件使用Log4j的内置类型转换来允许更多的数据类型（ 这是与Cassandra Appender相同的插件)。

要在开发过程中快速启动，使用基于JNDI的连接源的替代方法是使用非池化DriverManager连接源。 此连接源使用JDBC连接字符串，用户名和密码。 您也可以选择使用属性。

JDBCAppender参数：

配置JDBCAppender时，必须指定Appender从中获取JDBC连接的ConnectionSource实现。 您必须使用以下嵌套元素之一。

• DataSource：使用JNDI。
• ConnectionFactory：指向类 - 方法对以提供JDBC连接。
• DriverManager: A quick and dirty way to get off the ground, no connection pooling。
• PoolingDriver：使用Apache Commons DBCP提供连接池。

DataSource参数

ConnectionFactory参数

DriverManager参数

PoolingDriver参数（Apache Commons DBCP）

PoolableConnectionFactory参数（Apache Commons DBCP）

配置JDBCAppender时，使用嵌套的Column元素指定应该写入表中的哪些列以及如何写入它们。 JDBCAppender使用此信息来制定PreparedStatement以插入没有SQL注入漏洞的记录。

Column 参数

ColumnMapping参数

以下是JDBCAppender的一些示例配置，以及一个使用共享池和共享DBCP来共享数据库连接的示例工厂实现:

<?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>

<?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();
    }
}

这个appender是MapMessage-aware

以下配置使用MessageLayout指示Appender在设置Appender的SQL INSERT语句的值时应将MapMessage的键与ColumnMappings的名称匹配。 这使您可以基于Log4j MapMessage而不是LogEvents中的值，在数据库表中插入自定义值的行。

<Configuration status="debug">
 
  <Appenders>
    <Console name="STDOUT">
      <PatternLayout pattern="%C{1.} %m %level MDC%X%n"/>
    </Console>
    <Jdbc name="databaseAppender" tableName="dsLogEntry" ignoreExceptions="false">
      <DataSource jndiName="java:/comp/env/jdbc/TestDataSourceAppender" />
      <ColumnMapping name="Id" />
      <ColumnMapping name="ColumnA" />
      <ColumnMapping name="ColumnB" />
      <MessageLayout />
    </Jdbc>
  </Appenders>
 
  <Loggers>
    <Logger name="org.apache.logging.log4j.core.appender.db" level="debug" additivity="false">
      <AppenderRef ref="databaseAppender" />
    </Logger>
 
    <Root level="fatal">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>
 
</Configuration>

JMS Appender

MS Appender将格式化的日志事件发送到JMS目的地。

请注意，在Log4j 2.0中，此appender被拆分为JMSQueueAppender和JMSTopicAppender。 从Log4j 2.1开始，这些appender被组合到JMS Appender中，它不区分Queue和Topic。 但是，为2.0编写的使用或元素的配置将继续使用新的配置元素。

JMS Appender参数

以下是JMS Appender配置示例：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp">
  <Appenders>
    <JMS name="jmsQueue" destinationBindingName="MyQueue"
         factoryBindingName="MyQueueConnectionFactory">
      <JsonLayout properties="true"/>
    </JMS>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="jmsQueue"/>
    </Root>
  </Loggers>
</Configuration>

要将Log4j MapMessages映射到JMS javax.jms.MapMessages，请使用< MessageLayout />（自2.9以来）将appender的布局设置为MessageLayout：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="MyApp">
  <Appenders>
    <JMS name="jmsQueue" destinationBindingName="MyQueue"
         factoryBindingName="MyQueueConnectionFactory">
      <MessageLayout />
    </JMS>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="jmsQueue"/>
    </Root>
  </Loggers>
</Configuration>

JPAAppender

从Log4j 2.11.0开始，JPA支持已从现有模块logj-core转移到新模块log4j-jpa。

JPAAppender使用Java Persistence API 2.1将日志事件写入关系数据库表。 它需要API和提供程序实现在类路径上。 它还需要一个装饰实体，配置为持久保存到所需的表。 实体应该扩展org.apache.logging.log4j.core.appender.db.jpa.BasicLogEventEntity（如果你最想使用默认映射）并提供至少一个@Id属性，或者org.apache.logging.log4j .core.appender.db.jpa.AbstractLogEventWrapperEntity（如果要显着自定义映射）。 有关更多信息，请参阅这两个类的Javadoc。 您还可以查阅这两个类的源代码，作为如何实现该实体的示例。

JPAAppender参数

以下是JPAAppender的示例配置。 第一个XML示例是Log4j配置文件，第二个是persistence.xml文件。 这里假设是EclipseLink，但任何JPA 2.1或更高版本的提供程序都可以。 您应始终为记录创建单独的持久性单元，原因有两个。 首先，< shared-cache-mode>必须设置为“NONE”，这在正常的JPA使用中通常是不希望的。 此外，出于性能原因，日志记录实体应该在其自己的持久性单元中与所有其他实体隔离，并且您应该使用非JTA数据源。 请注意，您的持久性单元还必须包含所有org.apache.logging.log4j.core.appender.db.jpa的< class>元素。 转换器转换器类。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
  <Appenders>
    <JPA name="databaseAppender" persistenceUnitName="loggingPersistenceUnit"
         entityClassName="com.example.logging.JpaLogEntity" />
  </Appenders>
  <Loggers>
    <Root level="warn">
      <AppenderRef ref="databaseAppender"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
                                 http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
             version="2.1">
 
  <persistence-unit name="loggingPersistenceUnit" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapJsonAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackJsonAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.MarkerAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.MessageAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.StackTraceElementAttributeConverter</class>
    <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ThrowableAttributeConverter</class>
    <class>com.example.logging.JpaLogEntity</class>
    <non-jta-data-source>jdbc/LoggingDataSource</non-jta-data-source>
    <shared-cache-mode>NONE</shared-cache-mode>
  </persistence-unit>
 
</persistence>

package com.example.logging;
...
@Entity
@Table(name="application_log", schema="dbo")
public class JpaLogEntity extends BasicLogEventEntity {
    private static final long serialVersionUID = 1L;
    private long id = 0L;
 
    public TestEntity() {
        super(null);
    }
    public TestEntity(LogEvent wrappedEvent) {
        super(wrappedEvent);
    }
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    public long getId() {
        return this.id;
    }
 
    public void setId(long id) {
        this.id = id;
    }
 
    // If you want to override the mapping of any properties mapped in BasicLogEventEntity,
    // just override the getters and re-specify the annotations.
}

package com.example.logging;
...
@Entity
@Table(name="application_log", schema="dbo")
public class JpaLogEntity extends AbstractLogEventWrapperEntity {
    private static final long serialVersionUID = 1L;
    private long id = 0L;
 
    public TestEntity() {
        super(null);
    }
    public TestEntity(LogEvent wrappedEvent) {
        super(wrappedEvent);
    }
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "logEventId")
    public long getId() {
        return this.id;
    }
 
    public void setId(long id) {
        this.id = id;
    }
 
    @Override
    @Enumerated(EnumType.STRING)
    @Column(name = "level")
    public Level getLevel() {
        return this.getWrappedEvent().getLevel();
    }
 
    @Override
    @Column(name = "logger")
    public String getLoggerName() {
        return this.getWrappedEvent().getLoggerName();
    }
 
    @Override
    @Column(name = "message")
    @Convert(converter = MyMessageConverter.class)
    public Message getMessage() {
        return this.getWrappedEvent().getMessage();
    }
    ...
}

HttpAppender

HttpAppender通过HTTP发送日志事件。 必须提供Layout以格式化LogEvent。
将等待来自服务器的响应，如果没有收到2xx响应则抛出错误。
使用HttpURLConnection实现。

HttpAppender参数

以下是HttpAppender配置代码示例：

<?xml version="1.0" encoding="UTF-8"?>
  ...
  <Appenders>
    <Http name="Http" url="https://localhost:9200/test/log4j/">
      <Property name="X-Java-Runtime" value="$${java:runtime}" />
      <JsonLayout properties="true"/>
      <SSL>
        <KeyStore   location="log4j2-keystore.jks" passwordEnvironmentVariable="KEYSTORE_PASSWORD"/>
        <TrustStore location="truststore.jks"      passwordFile="${sys:user.home}/truststore.pwd"/>
      </SSL>
    </Http>
  </Appenders>

KafkaAppender

KafkaAppender将事件记录到Apache Kafka。 每个日志事件都作为Kafka记录发送。

KafkaAppender参数

以下是KafkaAppender配置代码示例：

<?xml version="1.0" encoding="UTF-8"?>
  ...
  <Appenders>
    <Kafka name="Kafka" topic="log-test">
      <PatternLayout pattern="%date %message"/>
        <Property name="bootstrap.servers">localhost:9092</Property>
    </Kafka>
  </Appenders>

此appender默认是同步的，并且将阻塞，直到Kafka服务器确认记录为止，可以使用timeout.ms属性设置超时（默认为30秒）。 使用Async appender换行和/或将syncSend设置为false以异步记录。

这个appender需要Kafka客户端库。 请注意，您需要使用与所使用的Kafka服务器匹配的Kafka客户端库版本。

注意：确保不要让org.apache.kafka登录到DEBUG级别的Kafka appender，因为这会导致递归日志记录

<?xml version="1.0" encoding="UTF-8"?>
 ...
 <Loggers>
   <Root level="DEBUG">
     <AppenderRef ref="Kafka"/>
   </Root>
   <Logger name="org.apache.kafka" level="INFO" /> <!-- avoid recursive logging -->
 </Loggers>

MemoryMappedFileAppender

2.1以来的新功能。 请注意，这是一个新增功能，虽然它已经在多个平台上进行了测试，但它没有其他文件追加器那么多的跟踪记录。

MemoryMappedFileAppender将指定文件的一部分映射到内存中，并将日志事件写入此内存，依赖操作系统的虚拟内存管理器将更改同步到存储设备。 使用内存映射文件的主要好处是I / O性能。 这个appender可以简单地改变程序的本地内存，而不是进行系统调用来写入磁盘，这个内存的速度要快几个数量级。 此外，在大多数操作系统中，实际映射的内存区域是内核的页面缓存（文件缓存），这意味着不需要在用户空间中创建副本。 （TODO：将此appender的性能与RandomAccessFileAppender和FileAppender进行比较的性能测试。）

将文件区域映射到内存有一些开销，特别是非常大的区域（半千兆字节或更多）。 默认区域大小为32 MB，这应该在重映射操作的频率和持续时间之间达到合理的平衡。 （TODO：性能测试重新映射各种尺寸。）

与FileAppender和RandomAccessFileAppender类似，MemoryMappedFileAppender使用MemoryMappedFileManager实际执行文件I / O. 虽然无法共享来自不同Configuration的MemoryMappedFileAppender，但MemoryMappedFileManagers可以是Manager可访问的。 例如，servlet容器中的两个Web应用程序可以拥有自己的配置，并且如果Log4j位于两个共用的ClassLoader中，则可以安全地写入同一文件。

MemoryMappedFileAppender参数

以下是MemoryMappedFile配置示例：

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

NoSQLAppender

NoSQLAppender使用内部轻量级提供程序接口将日志事件写入NoSQL数据库。 MongoDB和Apache CouchDB目前存在Provider实现，编写自定义提供程序非常简单。

您可以通过在< NoSql>元素中指定适当的配置元素来指定要使用的NoSQL提供程序。 目前支持的类型是< MongoDb>和< CouchDb>。 要创建自己的自定义提供程序，请阅读NoSQLProvider，NoSQLConnection和NoSQLObject类的JavaDoc以及有关创建Log4j插件的文档。 我们建议您查看MongoDB和CouchDB提供程序的源代码，作为创建自己的提供程序的指南。

以下示例演示了如果以JSON格式表示，日志事件如何在NoSQL数据库中保留：

{
    "level": "WARN",
    "loggerName": "com.example.application.MyClass",
    "message": "Something happened that you might want to know about.",
    "source": {
        "className": "com.example.application.MyClass",
        "methodName": "exampleMethod",
        "fileName": "MyClass.java",
        "lineNumber": 81
    },
    "marker": {
        "name": "SomeMarker",
        "parent" {
            "name": "SomeParentMarker"
        }
    },
    "threadName": "Thread-1",
    "millis": 1368844166761,
    "date": "2013-05-18T02:29:26.761Z",
    "thrown": {
        "type": "java.sql.SQLException",
        "message": "Could not insert record. Connection lost.",
        "stackTrace": [
                { "className": "org.example.sql.driver.PreparedStatement$1", "methodName": "responder", "fileName": "PreparedStatement.java", "lineNumber": 1049 },
                { "className": "org.example.sql.driver.PreparedStatement", "methodName": "executeUpdate", "fileName": "PreparedStatement.java", "lineNumber": 738 },
                { "className": "com.example.application.MyClass", "methodName": "exampleMethod", "fileName": "MyClass.java", "lineNumber": 81 },
                { "className": "com.example.application.MainClass", "methodName": "main", "fileName": "MainClass.java", "lineNumber": 52 }
        ],
        "cause": {
            "type": "java.io.IOException",
            "message": "Connection lost.",
            "stackTrace": [
                { "className": "java.nio.channels.SocketChannel", "methodName": "write", "fileName": null, "lineNumber": -1 },
                { "className": "org.example.sql.driver.PreparedStatement$1", "methodName": "responder", "fileName": "PreparedStatement.java", "lineNumber": 1032 },
                { "className": "org.example.sql.driver.PreparedStatement", "methodName": "executeUpdate", "fileName": "PreparedStatement.java", "lineNumber": 738 },
                { "className": "com.example.application.MyClass", "methodName": "exampleMethod", "fileName": "MyClass.java", "lineNumber": 81 },
                { "className": "com.example.application.MainClass", "methodName": "main", "fileName": "MainClass.java", "lineNumber": 52 }
            ]
        }
    },
    "contextMap": {
        "ID": "86c3a497-4e67-4eed-9d6a-2e5797324d7b",
        "username": "JohnDoe"
    },
    "contextStack": [
        "topItem",
        "anotherItem",
        "bottomItem"
    ]
}

NoSQLAppender for MongoDB

从Log4 2.11.0开始，我们提供了两个MongoDB模块：

• log4j-mongodb2定义与MongoDB驱动程序版本2匹配的配置元素MongoDb2。
• log4j-mongodb3定义了匹配MongoDB驱动程序版本3的配置元素MongoDb3。
  我们不再提供log4j-mongodb模块。
  模块log4j-mongodb2将旧配置元素MongoDb别名为MongoDb2。

MongoDB 2的NoSQLAppender

本节详细介绍使用MongoDB驱动程序版本2的MongoDB NoSQLAppender提供程序的特殊性.NoSQLAppender Appender使用内部轻量级提供程序接口将日志事件写入NoSQL数据库。

MongoDB2提供的参数

这个appender是 MapMessage-aware。

以下是NoSQLAppender和MongoDB2提供程序的一些示例配置：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
  <Appenders>
    <NoSql name="databaseAppender">
      <MongoDb2 databaseName="applicationDb" collectionName="applicationLog" server="mongo.example.org"
               username="loggingUser" password="abc123" />
    </NoSql>
  </Appenders>
  <Loggers>
    <Root level="warn">
      <AppenderRef ref="databaseAppender"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
  <Appenders>
    <NoSql name="databaseAppender">
      <MongoDb2 collectionName="applicationLog" factoryClassName="org.example.db.ConnectionFactory"
               factoryMethodName="getNewMongoClient" />
    </NoSql>
  </Appenders>
  <Loggers>
    <Root level="warn">
      <AppenderRef ref="databaseAppender"/>
    </Root>
  </Loggers>
</Configuration>

从Log4j版本2.11.0开始，提供程序元素名称为MongoDb2。 名称MongoDb现在是MongoDb2的弃用别名。

MongoDB 3的NoSQLAppender

本节详细介绍使用MongoDB驱动程序版本3的MongoDB NoSQLAppender提供程序的特殊化.NoSQLAppender Appender使用内部轻量级提供程序接口将日志事件写入NoSQL数据库。

MongoDB3提供的参数

这个appender是MapMessage-aware。

以下是NoSQLAppender和MongoDB3提供程序的一些示例配置：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
  <Appenders>
    <NoSql name="databaseAppender">
      <MongoDb3 databaseName="applicationDb" collectionName="applicationLog" server="mongo.example.org"
               username="loggingUser" password="abc123" />
    </NoSql>
  </Appenders>
  <Loggers>
    <Root level="warn">
      <AppenderRef ref="databaseAppender"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error">
  <Appenders>
    <NoSql name="databaseAppender">
      <MongoDb3 collectionName="applicationLog" factoryClassName="org.example.db.ConnectionFactory"
               factoryMethodName="getNewMongoClient" />
    </NoSql>
  </Appenders>
  <Loggers>
    <Root level="warn">
      <AppenderRef ref="databaseAppender"/>
    </Root>
  </Loggers>
</Configuration>