{"id":5419,"date":"2023-09-26T02:40:30","date_gmt":"2023-09-26T01:40:30","guid":{"rendered":"https:\/\/www.baeldung.com\/java-log4j2-config-with-prop-file"},"modified":"2023-09-26T02:40:30","modified_gmt":"2023-09-26T01:40:30","slug":"log4j-2-configuration-using-a-properties-file","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/09\/26\/log4j-2-configuration-using-a-properties-file\/","title":{"rendered":"Log4j 2 Configuration Using a Properties File"},"content":{"rendered":"

\"\"<\/p>\n

1. Introduction<\/h2>\n
<\/div>\n

Log4j 2 is a popular, open-source logging framework<\/a> written in Java. It was introduced to overcome various architectural flaws of Log4j. It’s thread-safe, fast, and provides various improvements over its predecessor. It’s distributed under the open-source Apache Software License.<\/p>\n

Log4j 2<\/a> is the latest and improved version of the classic Log4j framework that reached the end of its life on August 5, 2015. However, Log4j is still widely used in many Java enterprise applications as a logging framework.<\/strong><\/p>\n

In this tutorial, we’ll learn about Log4j 2, its benefits over Log4j, and how to configure its core components using the log4j2.properties<\/em> file in Java.<\/p>\n

2. Maven Setup<\/h2>\n
<\/div>\n

We’ll need the log4j-core<\/em>\u00a0dependency in our\u00a0pom.xml<\/em> to start with:<\/p>\n

<dependency>\r\n    <groupId>org.apache.logging.log4j<\/groupId>\r\n    <artifactId>log4j-core<\/artifactId>\r\n    <version>2.20.0<\/version>\r\n<\/dependency>\r\n<dependency>\r\n    <groupId>org.apache.logging.log4j<\/groupId>\r\n    <artifactId>log4j-api<\/artifactId>\r\n    <version>2.20.0<\/version>\r\n<\/dependency><\/code><\/pre>\n
We can find the latest version of log4j-core<\/em><\/a>\u00a0and log4j-api<\/em><\/a> in the Maven Repository.<\/p>\n
3. Log4j 2 Logger<\/em><\/h2>\n
<\/div>\n
Unlike in Log4j, where we use Logger.getLogger()<\/em> to get a Logger<\/em> instance with a specific name, in Log4j 2 we use LogManager.getLogger()<\/em>:<\/p>\n
private static final Logger logger = LogManager.getLogger(Log4j2Example.class);<\/code><\/pre>\n
The LogManager<\/em> reads the initial configuration parameters from a configuration file or a configuration class. A Logger<\/em> is associated with LoggerConfig<\/em>, which is associated with Appender<\/em>s that actually deliver the log events.<\/p>\n
If we call LogManager.getLogger()<\/em> by passing the same (class) name, we’ll always get the reference of the same logger instance.<\/strong><\/p>\n
Both Logger<\/em> and LoggerConfig<\/em> are named entities. Each Logger<\/em> references a LoggerConfig,<\/em> which can reference its parent, thus achieving the same effect.<\/p>\n
A Logger<\/em> follows a named hierarchy. This means a LoggerConfig<\/em> named “com.baeldung<\/em>” is a parent of the LoggerConfig<\/em> named “com.baeldung.foo<\/em>“.<\/p>\n
4. Log4j 2 Configuration<\/h2>\n
<\/div>\n
Unlike Log4j, which supports configuration only through properties and XML formats, we can define the Log4j 2 configurations using<\/strong> JSON, XML, YAML, or properties format. <\/strong>All these formats are functionally equivalent. Therefore, we can easily convert the configuration done in one format to any other.<\/p>\n
Moreover, Logj2 supports automatic configuration<\/a>, which means it’s capable of configuring itself automatically during initialization.<\/strong><\/p>\n
It scans and locates all the ConfigurationFactory<\/em> plugins at the start and arranges them in weighted order from highest to lowest – the properties file has the highest precedence of the value of 8<\/em>, followed by YAML, JSON, and XML.<\/p>\n
This means if we have logging configurations in the form of both the properties file and the XML file, then the precedence will be given to the properties file.<\/p>\n
5. The log4j2.properties<\/em> File<\/h2>\n
<\/div>\n
When Log4j 2 was released, it didn’t have the support for configuration through the properties file. It started supporting the properties file from the release of version 2.4.<\/p>\n
The default properties configuration file is always log4j2.properties<\/em>. The Logger<\/em> gets the reference of this file from the CLASSPATH<\/a><\/em>.<\/p>\n
However, if we need to use a different configuration file name, we can set it using the system property log4j.configurationFile<\/em>.<\/strong><\/p>\n
The system property may refer to a local file system or may contain a URL. Log4j 2 provides a DefaultConfiguration<\/em> if it cannot locate a configuration file. In this case, we get the logging output redirected to the console and the root logger<\/em> level set to ERROR<\/em>.<\/p>\n
6. Syntax of the log4j2.properties<\/em> File<\/h2>\n
<\/div>\n
The syntax of the log4j2.properties<\/em> file isn’t the same as that of log4j.properties<\/em>. In the log4j.properties<\/em> file, every configuration starts with ‘log4j<\/em>‘, while this has been omitted in the log4j2.properties<\/em> configuration.<\/p>\n
Let’s see the syntax of a general log4j2.properties<\/em> file:<\/p>\n
# The root logger with appender name \r\nrootLogger = DEBUG, STDOUT\r\n  \r\n# Assign STDOUT a valid appender & define its layout  \r\nappender.console.name = STDOUT\r\nappender.console.type = Console\r\nappender.console.layout.type = PatternLayout\r\nappender.console.layout.pattern = %msg%n  <\/code><\/pre>\n
Here, STDOUT<\/em> is the name of the Appender<\/em>. As discussed earlier, we can attach multiple appender<\/em>s to a logger<\/em> to direct logs to different destinations.<\/p>\n
Also, we should define a root logger in every Log4j 2 configuration. Otherwise, a default root LoggerConfig<\/em> that has an ERROR<\/em> level and ConsoleAppender <\/em>is used.<\/strong><\/p>\n
7. Examples<\/h2>\n
<\/div>\n
Now, let’s understand the log4j2.properties<\/em> file configurations for different appender<\/em>s<\/a> with the help of some examples.<\/p>\n
7.1. Sample Program<\/h3>\n
<\/div>\n
Let’s start with an example application that logs some messages:<\/p>\n
public class Log4j2ConsoleAndFile {\r\n    private static final Logger logger = LogManager.getLogger(Log4j2ConsoleAndFile.class);\r\n    public static void main(String[] args) {\r\n        logger.info(<span class="hljs-string">"Hello World!"<\/span>);\r\n        logger.debug(<span class="hljs-string">"Hello World!"<\/span>);\r\n    }\r\n}<\/code><\/pre>\n
7.2. Console Logging<\/h3>\n
<\/div>\n
The console is the default place for logging messages if no configuration file is located. Let’s create a log4j2.properties<\/em> configuration for the console Appender<\/em> with the root logger<\/em> and also define the logging level for it:<\/p>\n
# Root Logger\r\nrootLogger=DEBUG, <span class="hljs-string">STDOUT<\/span>\r\n# Direct log messages to stdout\r\n<span class="hljs-attr">appender.console.type<\/span> = <span class="hljs-string">Console\r\n<\/span><span class="hljs-attr">appender.console.name<\/span> = <span class="hljs-string">STDOUT\r\n<\/span><span class="hljs-attr">appender.console.layout.type<\/span> = <span class="hljs-string">PatternLayout\r\n<\/span><span class="hljs-attr">appender.console.layout.pattern<\/span> = <span class="hljs-string">[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n<\/span>\r\n<\/code><\/pre>\n
Here, we’ve defined a log4j2.properties<\/em> file with the following specifications:<\/p>\n