Introduction to Java Logging – Java日志的介绍

最后修改: 2016年 7月 11日

1. Overview


Logging is a powerful aid for understanding and debugging program’s run-time behavior. Logs capture and persist the important data and make it available for analysis at any point in time.


This article discusses the most popular java logging framewloorks, Log4j 2 and Logback, along with their predecessor Log4j, and briefly touches upon SLF4J, a logging facade that provides a common interface for different logging frameworks.

本文讨论了最流行的java日志框架,Log4j 2和Logback,以及它们的前身Log4j,并简要介绍了SLF4J,一个为不同日志框架提供通用接口的日志界面。

2. Enabling Logging


All the logging frameworks discussed in the article share the notion of loggers, appenders and layouts. Enabling logging inside the project follows three common steps:


  1. Adding needed libraries
  2. Configuration
  3. Placing log statements

The upcoming sections discuss the steps for each framework individually.


3. Log4j 2

3.Log4j 2

Log4j 2 is new and improved version of the Log4j logging framework. The most compelling improvement is the possibility of asynchronous logging. Log4j 2 requires the following libraries:

Log4j 2是Log4j日志框架的新改进版本。最引人注目的改进是可以进行异步日志记录。Log4j 2需要以下库。


Latest version of log4j-api you can find here and log4j-corehere.


3.1. Configuration


Configuring Log4j 2 is based on the main configuration log4j2.xml file. The first thing to configure is the appender.

配置Log4j 2是基于主配置log4j2.xml文件。首先要配置的是appender。

These determine where the log message will be routed. Destination can be a console, a file, socket, etc.


Log4j 2 has many appenders for different purposes, you can find more information on the official Log4j 2 site.

Log4j 2有许多用于不同目的的应用程序,你可以在官方Log4j 2网站上找到更多信息。

Lets take a look at a simple config example:


<Configuration status="debug" name="baeldung" packages="">
        <Console name="stdout" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} %p %m%n"/>

You can set a name for each appender, for example use name console instead of stdout.


Notice the PatternLayout element – this determines how message should look like. In our example, the pattern is set based on the pattern param, where %d determines date pattern, %p – output of log level, %m – output of logged message and %n – adds new line symbol. More info about pattern you can find on official Log4j 2 page.

注意PatternLayout元素–这决定了消息应该是什么样子。在我们的例子中,模式是根据pattern参数设置的,其中%d决定了日期模式,%p-输出日志级别,%m-输出日志信息,%n-添加新行符号。关于模式的更多信息,你可以在官方的Log4j 2页面找到。

Finally – to enable an appender (or multiple) you need to add it to <Root> section:


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

3.2. Logging to File


Sometimes you will need to use logging to a file, so we will add fout logger to our configuration:


    <File name="fout" fileName="baeldung.log" append="true">
            <Pattern>%d{yyyy-MM-dd HH:mm:ss} %-5p %m%nw</Pattern>

The File appender have several parameters that can be configured:


  • file – determines file name of the log file
  • append – The default value for this param is true, meaning that by default a File appender will append to an existing file and not truncate it.
  • PatternLayout that was described in previous example.

In order to enable File appender you need to add it to <Root> section:


<Root level="INFO">
    <AppenderRef ref="stdout" />
    <AppenderRef ref="fout"/>

3.3. Asynchronous Logging


If you want to make your Log4j 2 asynchronous you need to add LMAX disruptor library to your pom.xml. LMAX disruptor is a lock-free inter-thread communication library.

如果你想让你的Log4j 2成为异步的,你需要在你的pom.xml中添加LMAX disruptor库。LMAX disruptor是一个无锁线程间通信库。

Adding disruptor to pom.xml:



Latest version of disruptor can be found here.


If you want to use LMAX disruptor you need to use <asyncRoot> instead of <Root> in your configuration.


<AsyncRoot level="DEBUG">
    <AppenderRef ref="stdout" />
    <AppenderRef ref="fout"/>

Or you can enable asynchronous logging by setting the system property Log4jContextSelector to org.apache.logging.log4j.core.async.AsyncLoggerContextSelector.


You can of course read more about the configuration of the Log4j2 async logger and see some performance diagrams on the Log4j2 official page .


3.4. Usage


The following is a simple example that demonstrates the use of Log4j for logging:


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

public class Log4jExample {

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

    public static void main(String[] args) {
        logger.debug("Debug log message");"Info log message");
        logger.error("Error log message");

After running, the application will log the following messages to both console and file named baeldung.log:


2016-06-16 17:02:13 INFO  Info log message
2016-06-16 17:02:13 ERROR Error log message

If you elevate the root log level to ERROR:


<level value="ERROR" />

The output will look like the following:


2016-06-16 17:02:13 ERROR Error log message

As you can see, changing the log level to upper parameter causes the messages with lower log levels will not be print to appenders.


Method logger.error can be also used to log an exception that occurred:


try {
    // Here some exception can be thrown
} catch (Exception e) {
    logger.error("Error log message", throwable);

3.5. Package Level Configuration


Let’s say you need to show messages with the log level TRACE – for example from a specific package such as com.baeldung.log4j2:


logger.trace("Trace log message");

For all other packages you want to continue logging only INFO messages.


Keep in mind that TRACE is lower than the root log level INFO that we specified in configuration.


To enable logging only for one of packages you need to add the following section before <Root> to your log4j2.xml:


<Logger name="com.baeldung.log4j2" level="debug">
    <AppenderRef ref="stdout"/>

It will enable logging for com.baeldung.log4j package and your output will look like:


2016-06-16 17:02:13 TRACE Trace log message
2016-06-16 17:02:13 DEBUG Debug log message
2016-06-16 17:02:13 INFO  Info log message
2016-06-16 17:02:13 ERROR Error log message

4. Logback


Logback is meant to be an improved version of Log4j, developed by the same developer who made Log4j.


Logback also has a lot more features compared to Log4j, with many of them being introduced into Log4j 2 as well. Here’s a quick look at all of the advantages of Logback on the official site.

与Log4j相比,Logback还拥有更多的功能,其中许多功能也被引入到Log4j 2中。下面是在官方网站上对Logback的所有优点的简要介绍。

Let’s start by adding the following dependency to the pom.xml:



This dependency will transitively pull in another two dependencies, the logback-core and slf4j-api. Note that the latest version of Logback can be found here.

这一依赖关系将过渡性地拉入另外两个依赖关系,即logback-coreslf4j-api。请注意,Logback 的最新版本可以在这里找到。

4.1. Configuration


Let’s now have a look at a Logback configuration example:


  # Console appender
  <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
    <layout class="ch.qos.logback.classic.PatternLayout">
      # Pattern of log message for console appender
      <Pattern>%d{yyyy-MM-dd HH:mm:ss} %-5p %m%n</Pattern>

  # File appender
  <appender name="fout" class="ch.qos.logback.core.FileAppender">
      # Pattern of log message for file appender
      <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5p %m%n</pattern>

  # Override log level for specified package
  <logger name="com.baeldung.log4j" level="TRACE"/>

  <root level="INFO">
    <appender-ref ref="stdout" />
    <appender-ref ref="fout" />

Logback uses SLF4J as an interface, so you need to import SLF4J’s Logger and LoggerFactory.


4.2. SLF4J


SLF4J provides a common interface and abstraction for most of the Java logging frameworks. It acts as a facade and provides standardized API for accessing the underlying features of the logging framework.


Logback uses SLF4J as native API for its functionality. Following is the example using Logback logging:


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

public class Log4jExample {

    private static Logger logger = LoggerFactory.getLogger(Log4jExample.class);

    public static void main(String[] args) {
        logger.debug("Debug log message");"Info log message");
        logger.error("Error log message");

The output will remain the same as in previous examples.


5. Log4J


Finally, let’s have a look at the venerable Log4j logging framework.


At this point it’s of course outdated, but worth discussing as it lays the foundation for its more modern successors.


Many of the configuration details match those discussed in Log4j 2 section.

许多配置细节与Log4j 2章节中讨论的一致。

5.1. Configuration


First of all you need to add Log4j library to your projects pom.xml:



Here you should be able to find latest version of Log4j.


Lets take a look at a complete example of simple Log4j configuration with only one console appender:


<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" >
<log4j:configuration debug="false">

    <!--Console appender-->
    <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" 
              value="%d{yyyy-MM-dd HH:mm:ss} %p %m%n" />

        <level value="INFO" />
        <appender-ref ref="stdout" />


<log4j:configuration debug=”false”> is open tag of whole configuration which has one property – debug. It determines whether you want to add Log4j debug information to logs.

<log4j:configuration debug=”false”>是整个配置的开放标签,它有一个属性 – debug。它决定了你是否要在日志中添加Log4j的调试信息。

5.2. Usage


After you have added Log4j library and configuration you can use logger in your code. Lets take a look at a simple example:


import org.apache.log4j.Logger;

public class Log4jExample {
    private static Logger logger = Logger.getLogger(Log4jExample.class);

    public static void main(String[] args) {
        logger.debug("Debug log message");"Info log message");
        logger.error("Error log message");

6. Conclusion


This article shows very simple examples of how you can use different logging framework such as Log4j, Log4j2 and Logback. It covers simple configuration examples for all of the mentioned frameworks.


The examples that accompany the article can be found over on GitHub.