Configuration

将日志请求插入应用程序代码需要大量的计划和工作。观察表明，大约 4％的代码专用于日志记录。因此，即使大小适中的应用程序也将在其代码中嵌入数千个日志记录语句。给定它们的数量，就必须 Management 这些日志语句，而无需手动修改它们。

Log4j 2 的配置可以通过以下 4 种方式之一完成：

• 通过以 XML，JSON，YAML 或属性格式编写的配置文件。

• 通过创建 ConfigurationFactory 和 Configuration 实现以编程方式。

• 通过调用配置界面中公开的 API，以编程方式将组件添加到默认配置。

• 通过调用内部 Logger 类上的方法以编程方式。

该页面主要侧重于通过配置文件配置 Log4j。有关以编程方式配置 Log4j 的信息，请参见扩展 Log4j 2和编程 Log4j 配置。

请注意，与 Log4j 1.x 不同，公共 Log4j 2 API 不会公开用于添加，修改或删除附加程序和过滤器或以任何方式操纵配置的方法。

Automatic Configuration

Log4j 能够在初始化期间自动进行自我配置。 Log4j 启动时，它将找到所有 ConfigurationFactory 插件，并按从高到低的加权 Sequences 排列它们。交付时，Log4j 包含四个 ConfigurationFactory 实现：一个用于 JSON，一个用于 YAML，一个用于属性，以及一个用于 XML。

• Log4j 将检查“ log4j.configurationFile”系统属性，如果已设置，将尝试使用与文件 extensions 匹配的 ConfigurationFactory 加载配置。请注意，这不限于本地文件系统上的位置，并且可以包含 URL。

• 如果未设置任何系统属性，则属性 ConfigurationFactory 将在 Classpath 中查找 log4j2-test.properties。

• 如果找不到此类文件，则 YAML ConfigurationFactory 将在 Classpath 中查找 log4j2-test.yaml 或 log4j2-test.yml。

• 如果找不到此类文件，则 JSON ConfigurationFactory 将在 Classpath 中查找 log4j2-test.json 或 log4j2-test.jsn。

• 如果找不到这样的文件，XML ConfigurationFactory 将在 Classpath 中查找 log4j2-test.xml。

• 如果找不到测试文件，则属性 ConfigurationFactory 将在 Classpath 上查找 log4j2.properties。

• 如果找不到属性文件，则 YAML ConfigurationFactory 将在 Classpath 上查找 log4j2.yaml 或 log4j2.yml。

• 如果无法找到 YAML 文件，则 JSON ConfigurationFactory 将在 Classpath 上查找 log4j2.json 或 log4j2.jsn。

• 如果无法找到 JSON 文件，XML ConfigurationFactory 将尝试在 Classpath 上找到 log4j2.xml。

• 如果找不到配置文件，将使用 DefaultConfiguration。这将导致日志记录输出进入控制台。

可以使用一个使用 log4j 的名为 MyApp 的示例应用程序来说明如何完成此操作。

import com.foo.Bar;

// Import log4j classes.
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

public class MyApp {

    // Define a static logger variable so that it references the
    // Logger instance named "MyApp".
    private static final Logger logger = LogManager.getLogger(MyApp.class);

    public static void main(final String... args) {

        // Set up a simple configuration that logs on the console.

        logger.trace("Entering application.");
        Bar bar = new Bar();
        if (!bar.doIt()) {
            logger.error("Didn't do it.");
        }
        logger.trace("Exiting application.");
    }
}

MyApp 首先导入与 log4j 相关的类。然后，它使用名称 MyApp 定义一个静态 Logger 变量，该变量恰好是该类的完全限定名称。

MyApp 使用 packagecom.foo 中定义的 Bar 类。

package com.foo;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

public class Bar {
  static final Logger logger = LogManager.getLogger(Bar.class.getName());

  public boolean doIt() {
    logger.entry();
    logger.error("Did it again!");
    return logger.exit(false);
  }
}

如果 Log4j 找不到配置文件，它将提供默认配置。 DefaultConfiguration 类中提供的默认配置将设置：

• 附加到根 Logger 的ConsoleAppender。

• 附加到 ConsoleAppender 的模式PatternLayout设置为模式“％d{HH:mm:ss.SSS} [％t]％-5level％logger{36}-％msg％n”

请注意，默认情况下，Log4j 将根记录程序分配给 Level.ERROR。

MyApp 的输出类似于：

17:13:01.540 [main] ERROR com.foo.Bar - Did it again!
17:13:01.540 [main] ERROR MyApp - Didn't do it.

如前所述，Log4j 将首先尝试从配置文件进行自我配置。等同于默认值的配置如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <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">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

将上面的文件作为 log4j2.xml 放入 Classpath 后，您将获得与上面列出的结果相同的结果。将根级别更改为跟踪将导致类似以下结果：

17:13:01.540 [main] TRACE MyApp - Entering application.
17:13:01.540 [main] TRACE com.foo.Bar - entry
17:13:01.540 [main] ERROR com.foo.Bar - Did it again!
17:13:01.540 [main] TRACE com.foo.Bar - exit with (false)
17:13:01.540 [main] ERROR MyApp - Didn't do it.
17:13:01.540 [main] TRACE MyApp - Exiting application.

请注意，使用默认配置时，状态日志记录被禁用。

Additivity

也许希望从 com.foo.Bar 之外的所有内容中消除所有 TRACE 输出。仅更改日志级别将无法完成任务。相反，解决方案是向配置添加新的 Logger 定义：

<Logger name="com.foo.Bar" level="TRACE"/>
<Root level="ERROR">
  <AppenderRef ref="STDOUT">
</Root>

使用此配置，将记录来自 com.foo.Bar 的所有日志事件，而仅记录来自所有其他组件的错误事件。

在前面的示例中，来自 com.foo.Bar 的所有事件仍被写入控制台。这是因为 com.foo.Bar 的 Logger 在其父 Logger 上没有配置任何附加程序。其实下面的配置

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Logger name="com.foo.Bar" level="trace">
      <AppenderRef ref="Console"/>
    </Logger>
    <Root level="error">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

会导致

17:13:01.540 [main] TRACE com.foo.Bar - entry
17:13:01.540 [main] TRACE com.foo.Bar - entry
17:13:01.540 [main] ERROR com.foo.Bar - Did it again!
17:13:01.540 [main] TRACE com.foo.Bar - exit (false)
17:13:01.540 [main] TRACE com.foo.Bar - exit (false)
17:13:01.540 [main] ERROR MyApp - Didn't do it.

请注意，来自 com.foo.Bar 的跟踪消息出现了两次。这是因为首先使用与 Loggercom.foo.Bar 关联的附加程序，该附加程序将第一个实例写入控制台。接下来，引用 com.foo.Bar 的父级(在本例中为 rootLogger)。然后将该事件传递到其附加程序，该附加程序还将写入控制台，从而导致第二个实例。这称为可加性。尽管可加性是一个非常方便的功能(例如在前面的第一个示例中，无需配置任何附加引用)，但在许多情况下，此行为被认为是不希望的，因此可以通过将 Logger 上的可加性属性设置为来禁用它假：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Logger name="com.foo.Bar" level="trace" additivity="false">
      <AppenderRef ref="Console"/>
    </Logger>
    <Root level="error">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

一旦事件的可加性设置为 false 到达 Logger，则无论事件的可加性设置如何，该事件都不会传递给其任何父 Logger。

Automatic Reconfiguration

从文件配置后，Log4j 能够自动检测对配置文件的更改并自行重新配置。如果在配置元素上指定了 monitorInterval 属性，并且将其设置为非零值，则下次评估和/或记录日志事件并且自上次检查以来已经过 monitorInterval 时，将检查文件。下例显示了如何配置属性，以便仅在至少 30 秒后检查配置文件中的更改。最小间隔为 5 秒。

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

Chainsaw 可以自动处理您的日志文件(广告附加程序配置)

Log4j 提供了“发布”所有基于文件的附加程序以及基于套接字的附加程序的附加程序配置详细信息的功能。例如，对于基于文件的附加程序，文件位置和文件中的图案布局包含在广告中。Chainsaw 和其他外部系统可以发现这些广告，并使用该信息来智能地处理日志文件。

广告公开的机制以及广告格式特定于每个 advertiser 实现。想要与特定的 Advertiser 实施一起使用的外部系统必须了解如何找到所发布的配置以及广告的格式。例如，“数据库”advertiser 可以将配置详细信息存储在数据库表中。外部系统可以读取该数据库表以发现文件位置和文件格式。

Log4j 提供了一个 advertiser 实现，即“ multicastdns”advertiser，该 advertiser 使用http://jmdns.sourceforge.net库通过 IP 多播来发布附加程序配置详细信息。

Chainsaw 会自动发现 log4j 的多播 dns 生成的广告，并在 Chainsaw 的 Zeroconf 选项卡中显示那些发现的广告(如果 jmdns 库在 Chainsaw 的 Classpath 中)。要开始解析和尾随广告中提供的日志文件，只需在 Chainsaw 的 Zeroconf 选项卡中双击广告条目。当前，Chainsaw 仅支持 FileAppender 广告。

公布附加程序配置：

• 将http://jmdns.sourceforge.net的 JmDns 库添加到应用程序 Classpath

• 将配置元素的“ advertiser”属性设置为“ multicastdns”

• 将 appender 元素上的'advertise'属性设置为'true'

• 如果发布基于 FileAppender 的配置，则将 appender 元素上的'advertiseURI'属性设置为适当的 URI

基于 FileAppender 的配置需要在附加程序上指定其他“ advertiseURI”属性。 “ advertiseURI”属性为 Chainsaw 提供有关如何访问文件的信息。例如，通过指定 Commons VFS(http://commons.apache.org/proper/commons-vfs/)sftp：// URI，可以通过 ssh/sftp 远程访问该文件，如果可以通过 Web 服务器访问该文件，则可以使用 http：// URI。如果从 Chainsaw 的本地运行实例访问文件，则可以指定 file：// URI。

这是示例的启用广告的附加程序配置，本地运行的 Chainsaw 可以使用该配置自动尾随日志文件(注意 file：// advertiseURI)：

请注意，您必须将http://jmdns.sourceforge.net的 JmDns 库添加到您的应用程序 Classpath 中，以便与“ multicastdns”广告 Client 进行广告.

<?xml version="1.0" encoding="UTF-8"?>
<Configuration advertiser="multicastdns">
...
</Configuration>
<Appenders>
  <File name="File1" fileName="output.log" bufferedIO="false" advertiseURI="file://path/to/output.log" advertise="true">
  ...
  </File>
</Appenders>

Configuration Syntax

从 2.9 版开始，出于安全原因，Log4j 不处理 XML 文件中的 DTD。如果要将配置拆分为多个文件，请使用XInclude或Composite Configuration。

正如前面的示例以及后面的示例所示，Log4j 允许您轻松地重新定义日志记录行为，而无需修改应用程序。可以禁用应用程序某些部分的日志记录，仅在满足特定条件(例如针对特定用户执行的操作)，将输出路由到 Flume 或日志报告系统等特定条件时记录日志。要做到这一点，需要了解配置文件的语法。

XML 文件中的配置元素接受几个属性：

使用 XML 进行配置

可以使用两种 XML 版本配置 Log4j。简洁严格。简洁的格式使配置非常容易，因为元素名称与它们表示的组件相匹配，但是无法使用 XML 模式进行验证。例如，通过在其父 appenders 元素下声明一个名为 Console 的 XML 元素来配置 ConsoleAppender。但是，元素和属性名称不区分大小写。另外，可以将属性指定为 XML 属性，也可以指定为没有属性且具有文本值的 XML 元素。所以

<PatternLayout pattern="%m%n"/>

and

<PatternLayout>
  <Pattern>%m%n</Pattern>
</PatternLayout>

are equivalent.

下面的文件表示 XML 配置的结构，但是请注意，下面的斜体元素表示将出现在其位置的简洁元素名称。

<?xml version="1.0" encoding="UTF-8"?>;
<Configuration>
  <Properties>
    <Property name="name1">value</property>
    <Property name="name2" value="value2"/>
  </Properties>
  <filter  ... />
  <Appenders>
    <appender ... >
      <filter  ... />
    </appender>
    ...
  </Appenders>
  <Loggers>
    <Logger name="name1">
      <filter  ... />
    </Logger>
    ...
    <Root level="level">
      <AppenderRef ref="name"/>
    </Root>
  </Loggers>
</Configuration>

有关附加器，过滤器和 Logger 声明的示例，请参见本页上的许多示例。

Strict XML

除了上述简洁的 XML 格式外，Log4j 还允许以更“常规”的 XML 方式指定配置，可以使用 XML Schema 对其进行验证。这可以通过将上面的友好元素名称替换为其对象类型来实现，如下所示。例如，不是使用名为 Console 的元素来配置 ConsoleAppender，而是将其配置为具有包含“ Console”的 type 属性的 appender 元素。

<?xml version="1.0" encoding="UTF-8"?>;
<Configuration>
  <Properties>
    <Property name="name1">value</property>
    <Property name="name2" value="value2"/>
  </Properties>
  <Filter type="type" ... />
  <Appenders>
    <Appender type="type" name="name">
      <Filter type="type" ... />
    </Appender>
    ...
  </Appenders>
  <Loggers>
    <Logger name="name1">
      <Filter type="type" ... />
    </Logger>
    ...
    <Root level="level">
      <AppenderRef ref="name"/>
    </Root>
  </Loggers>
</Configuration>

以下是使用严格格式的示例配置。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" strict="true" name="XMLConfigTest"
               packages="org.apache.logging.log4j.test">
  <Properties>
    <Property name="filename">target/test.log</Property>
  </Properties>
  <Filter type="ThresholdFilter" level="trace"/>

  <Appenders>
    <Appender type="Console" name="STDOUT">
      <Layout type="PatternLayout" pattern="%m MDC%X%n"/>
      <Filters>
        <Filter type="MarkerFilter" marker="FLOW" onMatch="DENY" onMismatch="NEUTRAL"/>
        <Filter type="MarkerFilter" marker="EXCEPTION" onMatch="DENY" onMismatch="ACCEPT"/>
      </Filters>
    </Appender>
    <Appender type="Console" name="FLOW">
      <Layout type="PatternLayout" pattern="%C{1}.%M %m %ex%n"/><!-- class and line number -->
      <Filters>
        <Filter type="MarkerFilter" marker="FLOW" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
        <Filter type="MarkerFilter" marker="EXCEPTION" onMatch="ACCEPT" onMismatch="DENY"/>
      </Filters>
    </Appender>
    <Appender type="File" name="File" fileName="${filename}">
      <Layout type="PatternLayout">
        <Pattern>%d %p %C{1.} [%t] %m%n</Pattern>
      </Layout>
    </Appender>
  </Appenders>

  <Loggers>
    <Logger name="org.apache.logging.log4j.test1" level="debug" additivity="false">
      <Filter type="ThreadContextMapFilter">
        <KeyValuePair key="test" value="123"/>
      </Filter>
      <AppenderRef ref="STDOUT"/>
    </Logger>

    <Logger name="org.apache.logging.log4j.test2" level="debug" additivity="false">
      <AppenderRef ref="File"/>
    </Logger>

    <Root level="trace">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>

</Configuration>

使用 JSON 进行配置

除了 XML，Log4j 可以使用 JSON 进行配置。 JSON 格式与简明 XML 格式非常相似。每个键代表一个插件的名称，与其关联的键/值对是其属性。如果键包含的内容不只是一个简单的值，它本身就是一个从属插件。在下面的示例中，ThresholdFilter，Console 和 PatternLayout 都是插件，而 Console 插件的 name 属性将被分配一个 STDOUT 值，并且 ThresholdFilter 将被分配一个调试级别。

{ "configuration": { "status": "error", "name": "RoutingTest",
                     "packages": "org.apache.logging.log4j.test",
      "properties": {
        "property": { "name": "filename",
                      "value" : "target/rolling1/rollingtest-$${sd:type}.log" }
      },
    "ThresholdFilter": { "level": "debug" },
    "appenders": {
      "Console": { "name": "STDOUT",
        "PatternLayout": { "pattern": "%m%n" },
        "ThresholdFilter": { "level": "debug" }
      },
      "Routing": { "name": "Routing",
        "Routes": { "pattern": "$${sd:type}",
          "Route": [
            {
              "RollingFile": {
                "name": "Rolling-${sd:type}", "fileName": "${filename}",
                "filePattern": "target/rolling1/test1-${sd:type}.%i.log.gz",
                "PatternLayout": {"pattern": "%d %p %c{1.} [%t] %m%n"},
                "SizeBasedTriggeringPolicy": { "size": "500" }
              }
            },
            { "AppenderRef": "STDOUT", "key": "Audit"}
          ]
        }
      }
    },
    "loggers": {
      "logger": { "name": "EventLogger", "level": "info", "additivity": "false",
                  "AppenderRef": { "ref": "Routing" }},
      "root": { "level": "error", "AppenderRef": { "ref": "STDOUT" }}
    }
  }
}

请注意，在 RoutingAppender 中，Route 元素已声明为数组。这是有效的，因为每个数组元素都是一个 Route 组件。这不适用于诸如追加程序和过滤器之类的元素，其中每个元素以简洁的格式具有不同的名称。如果每个追加器或过滤器声明一个名为“ type”的属性，其中包含追加器的类型，则追加器和过滤器可以定义为数组元素。以下示例说明了这一点，以及如何将多个 Logger 声明为一个数组。

{ "configuration": { "status": "debug", "name": "RoutingTest",
                      "packages": "org.apache.logging.log4j.test",
      "properties": {
        "property": { "name": "filename",
                      "value" : "target/rolling1/rollingtest-$${sd:type}.log" }
      },
    "ThresholdFilter": { "level": "debug" },
    "appenders": {
      "appender": [
         { "type": "Console", "name": "STDOUT", "PatternLayout": { "pattern": "%m%n" }, "ThresholdFilter": { "level": "debug" }},
         { "type": "Routing",  "name": "Routing",
          "Routes": { "pattern": "$${sd:type}",
            "Route": [
              {
                "RollingFile": {
                  "name": "Rolling-${sd:type}", "fileName": "${filename}",
                  "filePattern": "target/rolling1/test1-${sd:type}.%i.log.gz",
                  "PatternLayout": {"pattern": "%d %p %c{1.} [%t] %m%n"},
                  "SizeBasedTriggeringPolicy": { "size": "500" }
                }
              },
              { "AppenderRef": "STDOUT", "key": "Audit"}
            ]
          }
        }
      ]
    },
    "loggers": {
      "logger": [
        { "name": "EventLogger", "level": "info", "additivity": "false",
          "AppenderRef": { "ref": "Routing" }},
        { "name": "com.foo.bar", "level": "error", "additivity": "false",
          "AppenderRef": { "ref": "STDOUT" }}
      ],
      "root": { "level": "error", "AppenderRef": { "ref": "STDOUT" }}
    }
  }
}

使用 JSON 配置文件需要附加的runtime dependencies。

使用 YAML 进行配置

Log4j 还支持将 YAML 用于配置文件。该结构遵循与 XML 和 YAML 配置格式相同的模式。例如：

Configuration:
  status: warn
  name: YAMLConfigTest
  properties:
    property:
      name: filename
      value: target/test-yaml.log
  thresholdFilter:
    level: debug
  appenders:
    Console:
      name: STDOUT
      target: SYSTEM_OUT
      PatternLayout:
        Pattern: "%m%n"
    File:
      name: File
      fileName: ${filename}
      PatternLayout:
        Pattern: "%d %p %C{1.} [%t] %m%n"
      Filters:
        ThresholdFilter:
          level: error

  Loggers:
    logger:
      -
        name: org.apache.logging.log4j.test1
        level: debug
        additivity: false
        ThreadContextMapFilter:
          KeyValuePair:
            key: test
            value: 123
        AppenderRef:
          ref: STDOUT
      -
        name: org.apache.logging.log4j.test2
        level: debug
        additivity: false
        AppenderRef:
          ref: File
    Root:
      level: error
      AppenderRef:
        ref: STDOUT

使用 YAML 配置文件需要其他runtime dependencies。

配置属性

从 2.4 版开始，Log4j 现在支持通过属性文件进行配置。请注意，属性语法与 Log4j 1 中使用的语法不同。与 XML 和 JSON 配置一样，属性配置根据插件和插件属性定义配置。

在 2.6 版之前，属性配置要求您在带有这些名称的属性中以逗号分隔的列表中列出附加程序，过滤器和 Logger 的标识符。然后，将期望以组件开头的属性集中定义这些组件中的每个组件。\ <.identifier> ..标识符不必与要定义的组件名称匹配，但必须唯一地标识属于该组件的所有属性和子组件组件的。如果不存在标识符列表，则标识符不得包含“。”。每个组件必须指定一个“类型”属性，以标识该组件的插件类型。

从 2.6 版开始，不再需要该标识符列表，因为会在首次使用时推断出名称，但是，如果您希望使用更复杂的标识符，则仍必须使用该列表。如果列表存在，将使用它。

与基础组件不同，创建子组件时，不能指定包含标识符列表的元素。相反，您必须按照以下滚动文件追加器中策略定义中所示的类型定义 wrapper 元素。然后，您定义该包装器元素下方的每个子组件，因为下面定义了 TimeBasedTriggeringPolicy 和 SizeBasedTriggeringPolicy。

属性配置文件支持 advertiser，monitorInterval，名称，包，shutdownHook，shutdownTimeout，状态，详细和目标属性。有关这些属性的定义，请参见Configuration Syntax。

status = error
dest = err
name = PropertiesConfig

property.filename = target/rolling/rollingtest.log

filter.threshold.type = ThresholdFilter
filter.threshold.level = debug

appender.console.type = Console
appender.console.name = STDOUT
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %m%n
appender.console.filter.threshold.type = ThresholdFilter
appender.console.filter.threshold.level = error

appender.rolling.type = RollingFile
appender.rolling.name = RollingFile
appender.rolling.fileName = ${filename}
appender.rolling.filePattern = target/rolling2/test1-%d{MM-dd-yy-HH-mm-ss}-%i.log.gz
appender.rolling.layout.type = PatternLayout
appender.rolling.layout.pattern = %d %p %C{1.} [%t] %m%n
appender.rolling.policies.type = Policies
appender.rolling.policies.time.type = TimeBasedTriggeringPolicy
appender.rolling.policies.time.interval = 2
appender.rolling.policies.time.modulate = true
appender.rolling.policies.size.type = SizeBasedTriggeringPolicy
appender.rolling.policies.size.size=100MB
appender.rolling.strategy.type = DefaultRolloverStrategy
appender.rolling.strategy.max = 5

logger.rolling.name = com.example.my.app
logger.rolling.level = debug
logger.rolling.additivity = false
logger.rolling.appenderRef.rolling.ref = RollingFile

rootLogger.level = info
rootLogger.appenderRef.stdout.ref = STDOUT

Configuring Loggers

在尝试配置 Logger 之前，了解 Logger 在 Log4j 中的工作方式至关重要。如果需要更多信息，请参考 Log4j architecture。在不了解这些概念的情况下尝试配置 Log4j 会导致失败。

使用 logger 元素配置 LoggerConfig。 logger 元素必须指定了 name 属性，通常将指定了 level 属性，还可能指定了可加性。该级别可以配置为 TRACE，DEBUG，INFO，WARN，ERROR，ALL 或 OFF 之一。如果未指定级别，则默认为 ERROR。可加性属性可以被分配为真或 Pseudo 值。如果省略该属性，则将使用默认值 true。

捕获位置信息(类名，文件名，方法名和调用者的行号)可能很慢。 Log4j 尝试通过减小必须查找记录方法调用方的遍历堆栈的大小来优化此方法。它通过确定是否可以访问的任何组件都需要位置信息来做到这一点。如果将 Logger 配置为类似跟踪或调试的级别，并且期望大多数日志将在 Appender 引用或 Appender 上进行过滤，则这会导致性能问题，因为 Log4j 会计算位置信息，即使日志事件将被丢弃。要禁用此行为，可以在 LoggerConfig 上将 includeLocation 属性设置为 false。这将导致 Log4j 推迟计算位置信息，直到绝对必要为止。

可以使用将添加到从 ThreadContextMap 复制的属性中的属性来配置 LoggerConfig(包括根 LoggerConfig)。这些属性可以从 Appender，Filters，Layouts 等引用，就像它们是 ThreadContext Map 的一部分一样。这些属性可以包含将在解析配置时解析的变量，或者在记录每个事件时动态解析的变量。有关使用变量的更多信息，请参见Property Substitution。

LoggerConfig 也可以配置一个或多个 AppenderRef 元素。引用的每个追加程序都将与指定的 LoggerConfig 关联。如果在 LoggerConfig 上配置了多个附加程序，则在处理记录事件时将分别调用每个附加程序。

每个配置都必须具有 rootLogger 。如果未配置，将使用默认根 LoggerConfig，该根错误级别为 ERROR，并附加了控制台附加程序。根 Logger 和其他 Logger 之间的主要区别是

• 根 Logger 没有名称属性。

• 根 Logger 没有父项，因此不支持加性属性。

Configuring Appenders

可以使用特定的 appender 插件的名称来配置 appender，也可以使用 appender 元素和包含 appender 插件的名称的 type 属性来配置 appender。此外，每个附加程序都必须具有一个 name 属性，该属性指定的值在一组附加程序中是唯一的。Logger 将使用该名称来引用上一节中所述的附加程序。

大多数追加程序还支持要配置的布局(可以再次使用特定的布局插件的名称作为元素，也可以使用“ layout”作为元素名称以及包含布局插件的名称的 type 属性来指定。各种追加程序将包含它们正常运行所需的其他属性或元素。

Configuring Filters

Log4j 允许在以下四个位置中指定一个过滤器：

• 与追加程序，Logger 和属性元素处于同一级别。这些过滤器可以在事件被传递到 LoggerConfig 之前接受或拒绝事件。

• 在 Logger 元素中。这些过滤器可以接受或拒绝特定 Logger 的事件。

• 在追加元素中。这些过滤器可以防止或导致事件由附加程序处理。

• 在追加程序参考元素中。这些过滤器用于确定 Logger 是否应将事件路由到附加程序。

尽管只能配置一个过滤器元素，但该元素可以是代表 CompositeFilter 的 filters 元素。过滤器元素允许在其中配置任意数量的过滤器元素。以下示例显示如何在 ConsoleAppender 上配置多个过滤器。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" name="XMLConfigTest" packages="org.apache.logging.log4j.test">
  <Properties>
    <Property name="filename">target/test.log</Property>
  </Properties>
  <ThresholdFilter level="trace"/>

  <Appenders>
    <Console name="STDOUT">
      <PatternLayout pattern="%m MDC%X%n"/>
    </Console>
    <Console name="FLOW">
      <!-- this pattern outputs class name and line number -->
      <PatternLayout pattern="%C{1}.%M %m %ex%n"/>
      <filters>
        <MarkerFilter marker="FLOW" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
        <MarkerFilter marker="EXCEPTION" onMatch="ACCEPT" onMismatch="DENY"/>
      </filters>
    </Console>
    <File name="File" fileName="${filename}">
      <PatternLayout>
        <pattern>%d %p %C{1.} [%t] %m%n</pattern>
      </PatternLayout>
    </File>
  </Appenders>

  <Loggers>
    <Logger name="org.apache.logging.log4j.test1" level="debug" additivity="false">
      <ThreadContextMapFilter>
        <KeyValuePair key="test" value="123"/>
      </ThreadContextMapFilter>
      <AppenderRef ref="STDOUT"/>
    </Logger>

    <Logger name="org.apache.logging.log4j.test2" level="debug" additivity="false">
      <Property name="user">${sys:user.name}</Property>
      <AppenderRef ref="File">
        <ThreadContextMapFilter>
          <KeyValuePair key="test" value="123"/>
        </ThreadContextMapFilter>
      </AppenderRef>
      <AppenderRef ref="STDOUT" level="error"/>
    </Logger>

    <Root level="trace">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>

</Configuration>

Property Substitution

Log4j 2 支持在配置中指定标记作为对在其他位置定义的属性的引用的功能。当解释配置文件时，其中一些属性将被解析，而其他属性可能会传递到组件，在运行时将对其进行评估。为此，Log4j 使用Apache Commons Lang的StrSubstitutor和StrLookup类的变体。以类似于 Ant 或 Maven 的方式，这允许使用配置本身中声明的属性来解析声明为${name}的变量。例如，以下示例显示了将滚动文件附加程序的文件名声明为属性。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" name="RoutingTest" packages="org.apache.logging.log4j.test">
  <Properties>
    <Property name="filename">target/rolling1/rollingtest-$${sd:type}.log</Property>
  </Properties>
  <ThresholdFilter level="debug"/>

  <Appenders>
    <Console name="STDOUT">
      <PatternLayout pattern="%m%n"/>
      <ThresholdFilter level="debug"/>
    </Console>
    <Routing name="Routing">
      <Routes pattern="$${sd:type}">
        <Route>
          <RollingFile name="Rolling-${sd:type}" fileName="${filename}"
                       filePattern="target/rolling1/test1-${sd:type}.%i.log.gz">
            <PatternLayout>
              <pattern>%d %p %c{1.} [%t] %m%n</pattern>
            </PatternLayout>
            <SizeBasedTriggeringPolicy size="500" />
          </RollingFile>
        </Route>
        <Route ref="STDOUT" key="Audit"/>
      </Routes>
    </Routing>
  </Appenders>

  <Loggers>
    <Logger name="EventLogger" level="info" additivity="false">
      <AppenderRef ref="Routing"/>
    </Logger>

    <Root level="error">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>

</Configuration>

尽管这很有用，但属性可以来自更多地方。为了适应这种情况，Log4j 还支持语法${prefix:name}，其中前缀标识告诉 Log4j 变量名称应在特定上下文中求值。有关更多详细信息，请参见Lookups手册页。 Log4j 内置的上下文是：

Default Properites

通过将 Properties 元素直接放在 Configuration 元素之后以及声明任何 Logger，Filters，Appenders 等之前，可以在配置文件中声明默认属性 Map。如果不能在指定的查找中找到该值，则将使用默认属性 Map 中的值。默认 Map 预先填充了“ hostName”的值，该值是当前系统的主机名或 IP 地址，而“ contextName”的值是当前日志记录上下文的值。在很多地方，本节都将使用 Properties 元素作为示例。

还可以通过使用语法${lookupName:key:-defaultValue}在 Lookup 中指定默认属性。在某些情况下，键可能包含前导“-”。在这种情况下，必须包含转义字符，例如${main:--file:-app.properties}。这将使用 MainMapLookup 作为名为--file 的键。如果未找到密钥，则将 app.properties 用作默认值。

具有多个前导“ $”字符的查找变量

StrLookup 处理的一个有趣功能是，当每次解析变量时用多个前导“ $”字符声明变量引用时，都将简单删除前导“ $”。在前面的示例中，“ Routes”元素能够在运行时解析变量。为此，将前缀值指定为带有两个前导“ $”字符的变量。首次处理配置文件时，仅删除第一个“ $”字符。因此，在运行时评估 Routes 元素时，将使用变量声明“ ${sd:type}”来检查事件的 StructuredDataMessage，如果存在，则将其 type 属性的值用作路由键。并非所有元素都在运行时支持解析变量。这样做的组件将在其文档中明确指出。

如果没有在与前缀关联的 Lookup 中找到键的值，那么将使用配置文件中属性声明中与键关联的值。如果找不到值，则变量声明将作为值返回。可以通过以下操作在配置中声明默认值：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
  <Properties>
    <Property name="type">Audit</property>
  </Properties>
  ...
</Configuration>

作为一个脚注，值得指出的是，在处理配置时，RollingFile 追加器声明中的变量也将不被评估。这仅仅是因为整个 RollingFile 元素的分辨率会推迟到发生匹配之前。有关更多信息，请参见RoutingAppender。

Scripts

Log4j 支持在其某些组件中使用的JSR 223脚本语言。可以使用为 JSR 223 脚本引擎提供支持的任何语言。可以在Scripting Engine网站上找到语言及其绑定的列表。但是，其中列出的某些语言(例如 JavaScript，Groovy 和 Beanshell)直接支持 JSR 223 脚本框架，仅要求安装该语言的 jar。

支持使用脚本的组件通过允许在其上配置\ ，\ 或\ 元素来实现此目的。 script 元素包含脚本的名称，脚本的语言和脚本文本。 scriptFile 元素包含脚本的名称，位置，语言，字符集以及是否应监视文件的更改。 scriptRef 元素包含\ 配置元素中定义的脚本的名称。脚本的名称与脚本引擎一起用于存储脚本，因此可以在每次需要运行脚本时快速找到它。尽管名称不是必需的，但提供该名称将有助于在脚本运行时调试问题。该语言必须在脚本元素上提供，并且必须指定出现在配置状态日志中的语言名称之一，如下一节所述。如果未在 scriptFile 元素上指定语言，则语言将由脚本路径的文件 extensions 确定。如果请求文件监视，则只有在配置元素上指定了非零的 monitorInterval 时才启用。该间隔将用于检查文件中的更改。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" name="RoutingTest">
  <Scripts>
    <Script name="selector" language="javascript"><![CDATA[
            var result;
            if (logEvent.getLoggerName().equals("JavascriptNoLocation")) {
                result = "NoLocation";
            } else if (logEvent.getMarker() != null && logEvent.getMarker().isInstanceOf("FLOW")) {
                result = "Flow";
            }
            result;
            ]]></Script>
    <ScriptFile name="groovy.filter" path="scripts/filter.groovy"/>
  </Scripts>

  <Appenders>
    <Console name="STDOUT">
      <ScriptPatternSelector defaultPattern="%d %p %m%n">
        <ScriptRef ref="selector"/>
          <PatternMatch key="NoLocation" pattern="[%-5level] %c{1.} %msg%n"/>
          <PatternMatch key="Flow" pattern="[%-5level] %c{1.} ====== %C{1.}.%M:%L %msg ======%n"/>
      </ScriptPatternSelector>
      <PatternLayout pattern="%m%n"/>
    </Console>
  </Appenders>

  <Loggers>
    <Logger name="EventLogger" level="info" additivity="false">
        <ScriptFilter onMatch="ACCEPT" onMisMatch="DENY">
          <Script name="GroovyFilter" language="groovy"><![CDATA[
            if (logEvent.getMarker() != null && logEvent.getMarker().isInstanceOf("FLOW")) {
                return true;
            } else if (logEvent.getContextMap().containsKey("UserId")) {
                return true;
            }
            return false;
            ]]>
          </Script>
        </ScriptFilter>
      <AppenderRef ref="STDOUT"/>
    </Logger>

    <Root level="error">
      <ScriptFilter onMatch="ACCEPT" onMisMatch="DENY">
        <ScriptRef ref="groovy.filter"/>
      </ScriptFilter>
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>

</Configuration>

如果 Configuration 元素上的 status 属性设置为 DEBUG，则将列出当前安装的脚本引擎及其属性的列表。尽管某些引擎可能会说它们不是线程安全的，但 Log4j 采取了一些措施，以确保如果引擎通告其脚本不是线程安全的，则脚本将以线程安全的方式运行。

2015-09-27 16:13:22,925 main DEBUG Installed script engines
2015-09-27 16:13:22,963 main DEBUG AppleScriptEngine Version: 1.1, Language: AppleScript, Threading: Not Thread Safe,
            Compile: false, Names: {AppleScriptEngine, AppleScript, OSA}
2015-09-27 16:13:22,983 main DEBUG Groovy Scripting Engine Version: 2.0, Language: Groovy, Threading: MULTITHREADED,
            Compile: true, Names: {groovy, Groovy}
2015-09-27 16:13:23,030 main DEBUG BeanShell Engine Version: 1.0, Language: BeanShell, Threading: MULTITHREADED,
            Compile: true, Names: {beanshell, bsh, java}
2015-09-27 16:13:23,039 main DEBUG Mozilla Rhino Version: 1.7 release 3 PRERELEASE, Language: ECMAScript, Threading: MULTITHREADED,
            Compile: true, Names: {js, rhino, JavaScript, javascript, ECMAScript, ecmascript}

执行脚本时，将为它们提供一组变量，这些变量应允许它们完成预期执行的任务。请参阅各个组件的文档，以获取脚本可用的变量列表。

支持脚本编写的组件希望将返回值传递回调用 Java 代码。对于某些脚本语言来说，这不是问题，但是 Javascript 不允许 return 语句，除非它在函数中。但是，Javascript 将返回脚本中执行的最后一条语句的值。结果，如下所示的代码将导致所需的行为。

var result;
            if (logEvent.getLoggerName().equals("JavascriptNoLocation")) {
                result = "NoLocation";
            } else if (logEvent.getMarker() != null && logEvent.getMarker().isInstanceOf("FLOW")) {
                result = "Flow";
            }
            result;

关于 Beanshell 的特别说明

如果 JSR 223 脚本引擎支持编译脚本，则应该确定它们支持 Compilable 接口。 Beanshell 做到了。但是，无论何时调用 compile 方法，它都将引发错误(不是异常)。 Log4j 捕获了此错误，但在尝试编译每个 Beanshell 脚本时，将记录以下警告。然后，将在每次执行时解释所有 Beanshell 脚本。

2015-09-27 16:13:23,095 main DEBUG Script BeanShellSelector is compilable
2015-09-27 16:13:23,096 main WARN Error compiling script java.lang.Error: unimplemented
            at bsh.engine.BshScriptEngine.compile(BshScriptEngine.java:175)
            at bsh.engine.BshScriptEngine.compile(BshScriptEngine.java:154)
            at org.apache.logging.log4j.core.script.ScriptManager$MainScriptRunner.<init>(ScriptManager.java:125)
            at org.apache.logging.log4j.core.script.ScriptManager.addScript(ScriptManager.java:94)

XInclude

XML 配置文件可以包含其他带有XInclude的文件。这是一个示例 log4j2.xml 文件，其中包括另外两个文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration xmlns:xi="http://www.w3.org/2001/XInclude"
               status="warn" name="XIncludeDemo">
  <properties>
    <property name="filename">xinclude-demo.log</property>
  </properties>
  <ThresholdFilter level="debug"/>
  <xi:include href="log4j-xinclude-appenders.xml" />
  <xi:include href="log4j-xinclude-loggers.xml" />
</configuration>

log4j-xinclude-appenders.xml:

<?xml version="1.0" encoding="UTF-8"?>
<appenders>
  <Console name="STDOUT">
    <PatternLayout pattern="%m%n" />
  </Console>
  <File name="File" fileName="${filename}" bufferedIO="true" immediateFlush="true">
    <PatternLayout>
      <pattern>%d %p %C{1.} [%t] %m%n</pattern>
    </PatternLayout>
  </File>
</appenders>

log4j-xinclude-loggers.xml:

<?xml version="1.0" encoding="UTF-8"?>
<loggers>
  <logger name="org.apache.logging.log4j.test1" level="debug" additivity="false">
    <ThreadContextMapFilter>
      <KeyValuePair key="test" value="123" />
    </ThreadContextMapFilter>
    <AppenderRef ref="STDOUT" />
  </logger>

  <logger name="org.apache.logging.log4j.test2" level="debug" additivity="false">
    <AppenderRef ref="File" />
  </logger>

  <root level="error">
    <AppenderRef ref="STDOUT" />
  </root>
</loggers>

Composite Configuration

Log4j 允许通过将多个配置文件指定为 log4j.configurationFile 上用逗号分隔的文件路径的列表来使用多个配置文件，或者在使用 url 时通过添加辅助配置位置作为名为“ override”的查询参数来使用多个配置文件。可以通过在 log4j.mergeStrategy 属性上指定实现 MergeStrategy 接口的类来控制合并逻辑。默认的合并策略将使用以下规则合并文件：

• 全局配置属性与后续配置中的全局配置属性聚合，以替换先前配置中的属性，不同之处在于，将使用最高状态级别和最低 MonitorInterval 大于 0 的状态。

• 来自所有配置的属性被汇总。重复的属性替换了先前配置中的属性。

• 如果定义了多个过滤器，则过滤器将聚集在 CompositeFilter 下。由于未命名过滤器，可能会出现重复项。

• 脚本和 ScriptFile 引用被汇总。重复的定义将替换先前配置中的定义。

• Appender 汇总。具有相同名称的 Appender 将由更高版本的配置取代，包括 Appender 的所有子组件。

• Logger 全部聚合。Logger 属性被单独合并，重复项被以后的配置中的替换。Logger 上的 Appender 参考汇总在一起，重复项被以后的配置中的替换。如果定义了多个过滤器，则 Logger 上的过滤器将聚集在 CompositeFilter 下。由于未命名过滤器，可能会出现重复项。根据保留或丢弃其父 Appender 参考，过滤包含或丢弃的 Appender 参考下的过滤器。

Status Messages

正如希望能够诊断应用程序中的问题一样，经常需要能够诊断日志记录配置或已配置的组件中的问题。由于尚未配置日志记录，因此初始化期间无法使用“常规”日志记录。此外，附加程序中的常规日志记录可能会创建无限递归，Log4j 将检测到该递归并导致递归事件被忽略。为了适应这种需求，Log4j 2 API 包含一个StatusLogger。组件声明 StatusLogger 的实例，类似于：

protected final static Logger logger = StatusLogger.getLogger();

由于 StatusLogger 实现了 Log4j 2 API 的 Logger 接口，因此可以使用所有常规 Logger 方法。

配置 Log4j 时，有时有时需要查看生成的状态事件。这可以通过将 status 属性添加到配置元素来完成，也可以通过设置“ Log4jDefaultStatusLevel”系统属性来提供默认值。 status 属性的有效值为“ trace”，“ debug”，“ info”，“ warn”，“ error”和“ fatal”。以下配置将 status 属性设置为 debug。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" name="RoutingTest">
  <Properties>
    <Property name="filename">target/rolling1/rollingtest-$${sd:type}.log</Property>
  </Properties>
  <ThresholdFilter level="debug"/>

  <Appenders>
    <Console name="STDOUT">
      <PatternLayout pattern="%m%n"/>
      <ThresholdFilter level="debug"/>
    </Console>
    <Routing name="Routing">
      <Routes pattern="$${sd:type}">
        <Route>
          <RollingFile name="Rolling-${sd:type}" fileName="${filename}"
                       filePattern="target/rolling1/test1-${sd:type}.%i.log.gz">
            <PatternLayout>
              <pattern>%d %p %c{1.} [%t] %m%n</pattern>
            </PatternLayout>
            <SizeBasedTriggeringPolicy size="500" />
          </RollingFile>
        </Route>
        <Route ref="STDOUT" key="Audit"/>
      </Routes>
    </Routing>
  </Appenders>

  <Loggers>
    <Logger name="EventLogger" level="info" additivity="false">
      <AppenderRef ref="Routing"/>
    </Logger>

    <Root level="error">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>

</Configuration>

在启动期间，此配置产生：

2011-11-23 17:08:00,769 DEBUG Generated plugins in 0.003374000 seconds
2011-11-23 17:08:00,789 DEBUG Calling createProperty on class org.apache.logging.log4j.core.config.Property for element property with params(name="filename", value="target/rolling1/rollingtest-${sd:type}.log")
2011-11-23 17:08:00,792 DEBUG Calling configureSubstitutor on class org.apache.logging.log4j.core.config.PropertiesPlugin for element properties with params(properties={filename=target/rolling1/rollingtest-${sd:type}.log})
2011-11-23 17:08:00,794 DEBUG Generated plugins in 0.001362000 seconds
2011-11-23 17:08:00,797 DEBUG Calling createFilter on class org.apache.logging.log4j.core.filter.ThresholdFilter for element ThresholdFilter with params(level="debug", onMatch="null", onMismatch="null")
2011-11-23 17:08:00,800 DEBUG Calling createLayout on class org.apache.logging.log4j.core.layout.PatternLayout for element PatternLayout with params(pattern="%m%n", Configuration(RoutingTest), null, charset="null")
2011-11-23 17:08:00,802 DEBUG Generated plugins in 0.001349000 seconds
2011-11-23 17:08:00,804 DEBUG Calling createAppender on class org.apache.logging.log4j.core.appender.ConsoleAppender for element Console with params(PatternLayout(%m%n), null, target="null", name="STDOUT", ignoreExceptions="null")
2011-11-23 17:08:00,804 DEBUG Calling createFilter on class org.apache.logging.log4j.core.filter.ThresholdFilter for element ThresholdFilter with params(level="debug", onMatch="null", onMismatch="null")
2011-11-23 17:08:00,813 DEBUG Calling createRoute on class org.apache.logging.log4j.core.appender.routing.Route for element Route with params(AppenderRef="null", key="null", Node=Route)
2011-11-23 17:08:00,823 DEBUG Calling createRoute on class org.apache.logging.log4j.core.appender.routing.Route for element Route with params(AppenderRef="STDOUT", key="Audit", Node=Route)
2011-11-23 17:08:00,825 DEBUG Calling createRoutes on class org.apache.logging.log4j.core.appender.routing.Routes for element Routes with params(pattern="${sd:type}", routes={Route(type=dynamic default), Route(type=static Reference=STDOUT key='Audit')})
2011-11-23 17:08:00,827 DEBUG Calling createAppender on class org.apache.logging.log4j.core.appender.routing.RoutingAppender for element Routing with params(name="Routing", ignoreExceptions="null", Routes({Route(type=dynamic default),Route(type=static Reference=STDOUT key='Audit')}), Configuration(RoutingTest), null, null)
2011-11-23 17:08:00,827 DEBUG Calling createAppenders on class org.apache.logging.log4j.core.config.AppendersPlugin for element appenders with params(appenders={STDOUT, Routing})
2011-11-23 17:08:00,828 DEBUG Calling createAppenderRef on class org.apache.logging.log4j.core.config.plugins.AppenderRefPlugin for element AppenderRef with params(ref="Routing")
2011-11-23 17:08:00,829 DEBUG Calling createLogger on class org.apache.logging.log4j.core.config.LoggerConfig for element logger with params(additivity="false", level="info", name="EventLogger", AppenderRef={Routing}, null)
2011-11-23 17:08:00,830 DEBUG Calling createAppenderRef on class org.apache.logging.log4j.core.config.plugins.AppenderRefPlugin for element AppenderRef with params(ref="STDOUT")
2011-11-23 17:08:00,831 DEBUG Calling createLogger on class org.apache.logging.log4j.core.config.LoggerConfig$RootLogger for element root with params(additivity="null", level="error", AppenderRef={STDOUT}, null)
2011-11-23 17:08:00,833 DEBUG Calling createLoggers on class org.apache.logging.log4j.core.config.LoggersPlugin for element loggers with params(loggers={EventLogger, root})
2011-11-23 17:08:00,834 DEBUG Reconfiguration completed
2011-11-23 17:08:00,846 DEBUG Calling createLayout on class org.apache.logging.log4j.core.layout.PatternLayout for element PatternLayout with params(pattern="%d %p %c{1.} [%t] %m%n", Configuration(RoutingTest), null, charset="null")
2011-11-23 17:08:00,849 DEBUG Calling createPolicy on class org.apache.logging.log4j.core.appender.rolling.SizeBasedTriggeringPolicy for element SizeBasedTriggeringPolicy with params(size="500")
2011-11-23 17:08:00,851 DEBUG Calling createAppender on class org.apache.logging.log4j.core.appender.RollingFileAppender for element RollingFile with params(fileName="target/rolling1/rollingtest-Unknown.log", filePattern="target/rolling1/test1-Unknown.%i.log.gz", append="null", name="Rolling-Unknown", bufferedIO="null", immediateFlush="null", SizeBasedTriggeringPolicy(SizeBasedTriggeringPolicy(size=500)), null, PatternLayout(%d %p %c{1.} [%t] %m%n), null, ignoreExceptions="null")
2011-11-23 17:08:00,858 DEBUG Generated plugins in 0.002014000 seconds
2011-11-23 17:08:00,889 DEBUG Reconfiguration started for context sun.misc.Launcher$AppClassLoader@37b90b39
2011-11-23 17:08:00,890 DEBUG Generated plugins in 0.001355000 seconds
2011-11-23 17:08:00,959 DEBUG Generated plugins in 0.001239000 seconds
2011-11-23 17:08:00,961 DEBUG Generated plugins in 0.001197000 seconds
2011-11-23 17:08:00,965 WARN No Loggers were configured, using default
2011-11-23 17:08:00,976 DEBUG Reconfiguration completed

如果 status 属性设置为 error，则仅将错误消息写入控制台。这样可以排除配置错误。例如，如果将上面的配置更改为将状态设置为 error 并且 Logger 声明为：

<logger name="EventLogger" level="info" additivity="false">
  <AppenderRef ref="Routng"/>
</logger>

将产生以下错误消息。

2011-11-24 23:21:25,517 ERROR Unable to locate appender Routng for logger EventLogger

应用程序可能希望将状态输出定向到其他某个目标。这可以通过将 dest 属性设置为“ err”以将输出发送到 stderr 或文件位置或 URL 来实现。这也可以通过确保已配置的状态设置为 OFF，然后以编程方式配置应用程序来完成，例如：

StatusConsoleListener listener = new StatusConsoleListener(Level.ERROR);
StatusLogger.getLogger().registerListener(listener);

在 Maven 中进行测试

Maven 可以在构建周期中运行单元和功能测试。默认情况下，放置在 src/test/resources 中的所有文件都会自动复制到目标/测试类，并在执行任何测试期间包含在 Classpath 中。因此，将 log4j2-test.xml 放入此目录将导致使用它代替可能存在的 log4j2.xml 或 log4j2.json。因此，在测试期间可以使用与 Producing 使用的日志配置不同的日志配置。

Log4j 2 广泛使用的第二种方法是在 junit 测试类中用@BeforeClassComments 的方法中设置 log4j.configurationFile 属性。这将允许在测试期间使用任意命名的文件。

Log4j 2 也广泛使用的第三种方法是使用 LoggerContextRule JUnit 测试规则，该规则提供了其他方便的测试方法。这需要将 log4j-core test-jar 依赖项添加到您的测试范围依赖项。例如：

public class AwesomeTest {
    @Rule
    public LoggerContextRule init = new LoggerContextRule("MyTestConfig.xml");

    @Test
    public void testSomeAwesomeFeature() {
        final LoggerContext ctx = init.getLoggerContext();
        final Logger logger = init.getLogger("org.apache.logging.log4j.my.awesome.test.logger");
        final Configuration cfg = init.getConfiguration();
        final ListAppender app = init.getListAppender("List");
        logger.warn("Test message");
        final List<LogEvent> events = app.getEvents();
        // etc.
    }
}

System Properties

Log4j 文档引用了许多系统属性，这些属性可用于控制 Log4j 2 行为的各个方面。下表列出了这些属性以及它们的默认值和对其控制内容的描述。属性名称中存在的任何空格都是为了视觉流动，应将其删除。

请注意，从 Log4j 2.10 开始，所有系统属性名称均已标准化，以遵循一致的命名方案。虽然仍然支持旧属性名称以实现向后兼容性，但建议更新配置以使用新样式。该系统是可扩展的，并通过PropertySource界面启用。可以通过 Java SE 中的标准 ServiceLoader 机制添加其他属性源类。

属性可以被优先级较低的来源覆盖(例如-100 排在 100 之前)。默认情况下，以下来源均可用：

• PropertySource 优先级和描述*

以下是可用的全局配置属性的列表。请注意，与配置文件中可用的配置设置不同，每个 JVM 进程只能设置一次。 “属性名称”列包含属性文件和系统属性中使用的名称。等效环境变量的 Environemt 变量； 2.10 之前的名称使用“旧版属性名称”。

• Log4j 2 全局配置属性*