How to configure logging in a Java application?

Using SLF4J combined with Logback or Log4j2 is the recommended way to configure logs in Java applications. It introduces API and implementation libraries by adding corresponding Maven dependencies; 2. Obtain the logger through the LoggerFactory of SLF4J in the code, and write decoupled and efficient log code using parameterized logging methods; 3. Define log output format, level, target (console, file) and package-level log control through logback.xml or log4j2.xml configuration files; 4. Optionally enable the configuration file scanning function to achieve dynamic adjustment of log level, and Spring Boot can also be managed through Actuator endpoints; 5. Follow best practices, including avoiding recording sensitive information, reasonable use of log levels, and enabling log file scrolling to control disk occupation, thereby building a maintainable and high-performance log system.

Configuring logging in a Java application is essential for monitoring, debugging, and maintaining applications in production. The most common and flexible approach today uses the SLF4J API with a backend implementation like Logback or Log4j2. Below is a practical guide to set up logging effectively.

1. Choose a Logging Framework (SLF4J Implementation)

It's best practice to use SLF4J (Simple Logging Facade for Java) as the API, paired with a concrete logging framework like Logback or Log4j2 .

Option A: SLF4J Logback (Recommended for simplicity)

Add these dependencies to your pom.xml (for Maven):

 <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.12</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.11</version>
</dependency>

Logback automatically detects the SLF4J API and works out of the box.

Option B: SLF4J Log4j2

If you prefer Log4j2 (better performance, advanced features):

 <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
    <version>2.21.1</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.21.1</version>
</dependency>

Note: Log4j2 requires log4j-slf4j2-impl , not the older log4j-slf4j-impl .

2. Write Logging Code Using SLF4J

Use the SLF4J API in your Java classes:

 import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyApp {
    private static final Logger logger = LoggerFactory.getLogger(MyApp.class);

    public void doSomething() {
        logger.info("Starting operation");
        try {
            // some logic
            logger.debug("Processing item {}", "example");
        } catch (Exception e) {
            logger.error("Unexpected error occurred", e);
        }
    }
}

This keeps your code decoupled from the actual logging implementation.

3. Configure Logging Behavior via Configuration File

The behavior (log levels, output format, file output, etc.) is controlled by a config file.

For Logback: Use logback.xml

Place logback.xml in src/main/resources :

 <?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/application.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Set logging levels -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>

    <!-- Specific package level -->
    <logger name="com.example.myapp" level="DEBUG"/>
</configuration>

This setup logs to both console and file, with custom formatting.

For Log4j2: Use log4j2.xml

Place log4j2.xml in src/main/resources :

 <?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
        <File name="File" fileName="logs/app.log">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n"/>
        </File>
    </Appenders>
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="File"/>
        </Root>
        <Logger name="com.example.myapp" level="debug"/>
    </Logers>
</Configuration>

4. Control Log Levels Dynamically (Optional)

You can change log levels at runtime if using web frameworks like Spring Boot:

• Use Spring Boot Actuator with /actuator/loggers endpoint.
• Or implement JMX-based log level control in standalone apps.

Alternatively, some apps reload config changes automatically:

• Logback: Set <configuration scan="true" scanPeriod="30 seconds">
• Log4j2: Add monitorInterval="30" to <Configuration>

5. Best Practices

• Always use parameterized logging: logger.debug("User {} logged in from {}", user, ip);
• Avoid logging sensitive data (passwords, tokens).
• Use appropriate log levels:
  • ERROR : serious failures
  • WARN : potential issues
  • INFO : important lifecycle events
  • DEBUG : detailed info for troubleshooting
  • TRACE : very fine-grained data
• Rotate log files using RollingFileAppender (Logback) or RollingFileAppender (Log4j2) to avoid huge files.

Example (Logback rolling file):

 <appender name="ROLLING" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/app.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>logs/app.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
            <maxFileSize>10MB</maxFileSize>
        </timeBasedFileNamingAndTriggeringPolicy>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{ISO8601} %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

That's it. With SLF4J and a solid backend like Logback, you get flexible, maintainable logging with minimal overhead. Most modern Java apps follow this pattern, and it scales well from small tools to large microservices.

The above is the detailed content of How to configure logging in a Java application?. For more information, please follow other related articles on the PHP Chinese website!