{"id":2413,"date":"2016-04-07T09:09:58","date_gmt":"2016-04-07T13:09:58","guid":{"rendered":"http:\/\/springframework.guru\/?p=2413"},"modified":"2024-10-21T08:58:14","modified_gmt":"2024-10-21T12:58:14","slug":"using-log4j-2-spring-boot","status":"publish","type":"post","link":"https:\/\/springframework.guru\/using-log4j-2-spring-boot\/","title":{"rendered":"How to Use Log4J 2 with Spring Boot"},"content":{"rendered":"

Similar to accompanying application development activities, such as unit testing and documentation, logging is an integral part of any enterprise application. And Spring Boot applications are no different. Through logging, you get to see what the Spring Boot application code is really doing during monitoring, troubleshooting, and debugging. Spring Boot makes using a logging framework effortless. Out of the box, Spring Boot is very easy to use with Logback<\/a>. With Spring Boot’s default configuration, you can start writing out log messages\u00a0using the Logback framework.<\/p>\n

But what if you want to use Log4J 2?<\/em> Naturally, Spring Boot has support for Log4J 2 and a number of other popular logging frameworks. If you are new to Log4J 2, I wrote\u00a0an introductory post on Log4J 2 here<\/a>.<\/p>\n

Configuring Spring Boot to use Log4J 2 is easy to do. In this post, I will explain how to configure Spring Boot to use Log4J 2 over the Simple Logging Facade for Java (SL4J)<\/a> logging fa\u00e7ade.<\/p>\n

What is the SL4J Fa\u00e7ade?<\/h2>\n

Logging has been an important topic in the Java community for a long time. There is actually a fair amount of competition among the various logging frameworks. Determining which logging framework is the best has been a vigorously debated topic in the Java community. I’m not entering the “which logging framework is best” debate in this post. Each framework has its own merits and faults, and the landscape is always evolving.<\/p>\n

When developing enterprise class applications using the Spring Framework, a common theme is to avoid tight coupling. For example, using Spring’s dependency injection, it’s common to build an application which can use different data sources. It’s fairly common to use H2 in memory database for development and MySQL for your production database. This is made easy via the DataSource<\/a> interface, which is part of the standard Java API. H2 has an implementation of the DataSource interface. MySQL has an implementation of the DataSource interface. Through Spring configuration, we tell the IoC container which one we want to use at run time.<\/p>\n

Logging in Java has been the wild west for a long time.\u00a0Sun \/ Oracle did include a logging API as part of Java, but it never really caught on<\/a> in the Java community. I’m honestly having a hard time remembering ever seeing it used.<\/p>\n

While the Open Source community does offer a number of great logging solutions, as a developer, you don’t want to couple your code to a specific logging framework. This is where SLF4J steps in.<\/p>\n

SL4J is a fa\u00e7ade for commonly used logging frameworks, such as Java Util Logging<\/a>, Log4J, Log4J 2, and Logback. As a developer, you write logging code against the SL4J API. At deployment time, you have the flexibility to plug-in your desired logging framework. This is made possible through an intermediate bridge\/adapter layer, like this.
\n\"Log4J<\/a><\/p>\n

SL4J does not provide a complete logging solution. With SL4J, you cannot perform operations such as configuring appenders or setting logging levels. You perform such configurations through a configuration file of the logging framework in use. As the configuration file remains external to the application, no dependencies exist between your application code and the underlying logging framework.<\/p>\n

Should you not provide a logging configuration to SL4J, it won’t complain. You’re logging simply becomes a no-op operation. Which is nice since it won’t unintentionally cause errors in your application. But also something to be aware of, if you’re not getting logging output.<\/p>\n

\"Spring<\/a>
Click here to learn Spring Framework 5!<\/figcaption><\/figure>\n

Maven Dependencies<\/h2>\n

To use Log4J 2 in a Spring Boot application, we need to add the required dependencies to the Maven POM. The required steps are:<\/p>\n

    \n
  1. \n
      \n
    1. Use the latest Spring Boot version. At the time of writing this post, the Spring Boot version is 1.3.3.RELEASE.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
      . . .\n<parent>\n   <groupId>org.springframework.boot<\/groupId>\n   <artifactId>spring-boot-starter-parent<\/artifactId>\n   <version>1.3.3.RELEASE<\/version>\n   <relativePath\/> <!-- lookup parent from repository -->\n<\/parent>\n. . .\n<\/pre>\n
      Note<\/strong>: Spring Boot 1.2.4.RELEASE contains a bug, issue #3550<\/a>. When you define a log level through application.properties<\/strong>, the bug changes the parent logger level, and in worst case the root logger level. Although the bug was fixed in 1.2.6.RELEASE, I suggest using the 1.2.8.RELEASE if you want to stick with 1.2.x.<\/p>\n
        \n
      1. \n
          \n
        1. Add the SL4J dependencies.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
          . . .\n<dependency>\n   <groupId>org.slf4j<\/groupId>\n   <artifactId>slf4j-api<\/artifactId>\n   <version>1.7.19<\/version>\n<\/dependency>\n<dependency>\n   <groupId>org.apache.logging.log4j<\/groupId>\n   <artifactId>log4j-slf4j-impl<\/artifactId>\n   <version>2.5<\/version>\n<\/dependency>\n. . .\n<\/pre>\n
            \n
          1. \n
              \n
            1. Add the Log4J 2 dependencies.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
              . . .\n<dependency>\n   <groupId>org.apache.logging.log4j<\/groupId>\n   <artifactId>log4j-api<\/artifactId>\n   <version>2.5<\/version>\n<\/dependency>\n<dependency>\n   <groupId>org.apache.logging.log4j<\/groupId>\n   <artifactId>log4j-core<\/artifactId>\n   <version>2.5<\/version>\n<\/dependency>\n<dependency>\n   <groupId>org.apache.logging.log4j<\/groupId>\n   <artifactId>log4j-jcl<\/artifactId>\n   <version>2.5<\/version>\n<\/dependency>\n. . .\n<\/pre>\n
              In the configuration code above, the log4j-jcl<\/code> artifact is Apache Log4J Commons Logging Bridge<\/a>. It is required if you intend to route Spring Boot application.properties<\/strong> logging configuration to a Log4J 2 file appender.<\/p>\n
                \n
              1. \n
                  \n
                1. Exclude the built-in Logback dependency. This is necessary as Spring Boot will pick and use Logback if present in the classpath.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                  . . .\n<dependency>\n   <groupId>org.springframework.boot<\/groupId>\n   <artifactId>spring-boot-starter-security<\/artifactId>\n   <exclusions>\n      <exclusion>\n         <groupId>ch.qos.logback<\/groupId>\n         <artifactId>logback-classic<\/artifactId>\n      <\/exclusion>\n   <\/exclusions>\n<\/dependency>\n. . .\n<\/pre>\n
                  The complete Maven POM is this.<\/p>\n
                  pom.xml<\/h4>\n
                  <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n  xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0<\/modelVersion>\n\n  <groupId>guru.springframework<\/groupId>\n  <artifactId>blogposts<\/artifactId>\n  <version>0.0.1-SNAPSHOT<\/version>\n  <packaging>jar<\/packaging>\n\n  <name>Blog Posts<\/name>\n  <description>Misc Blog Posts<\/description>\n\n  <parent>\n    <groupId>org.springframework.boot<\/groupId>\n    <artifactId>spring-boot-starter-parent<\/artifactId>\n    <version>1.2.3.RELEASE<\/version>\n    <relativePath\/> <!-- lookup parent from repository -->\n  <\/parent>\n\n  <properties>\n    <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\n    <start-class>guru.springframework.blog.BlogPostsApplication<\/start-class>\n    <java.version>1.8<\/java.version>\n  <\/properties>\n\n  <dependencies>\n    <dependency>\n      <groupId>org.springframework.boot<\/groupId>\n      <artifactId>spring-boot-starter<\/artifactId>\n      <exclusions>\n        <exclusion>\n          <groupId>org.springframework.boot<\/groupId>\n          <artifactId>spring-boot-starter-logging<\/artifactId>\n        <\/exclusion>\n      <\/exclusions>\n    <\/dependency>\n    \n    <dependency>\n      <groupId>org.springframework.boot<\/groupId>\n      <artifactId>spring-boot-starter-test<\/artifactId>\n      <scope>test<\/scope>\n    <\/dependency>\n    <dependency>\n      <groupId>org.apache.logging.log4j<\/groupId>\n      <artifactId>log4j-api<\/artifactId>\n      <version>2.5<\/version>\n    <\/dependency>\n    <dependency>\n      <groupId>org.apache.logging.log4j<\/groupId>\n      <artifactId>log4j-core<\/artifactId>\n      <version>2.5<\/version>\n    <\/dependency>\n    <dependency>\n      <groupId>com.h2database<\/groupId>\n      <artifactId>h2<\/artifactId>\n      <scope>runtime<\/scope>\n    <\/dependency>\n    <dependency>\n      <groupId>org.hibernate<\/groupId>\n      <artifactId>hibernate-core<\/artifactId>\n      <version>4.3.10.Final<\/version>\n    <\/dependency>\n  <\/dependencies>\n  <build>\n    <plugins>\n      <plugin>\n        <groupId>org.springframework.boot<\/groupId>\n        <artifactId>spring-boot-maven-plugin<\/artifactId>\n      <\/plugin>\n    <\/plugins>\n  <\/build>\n\n<\/project><\/pre>\n
                  Logging Messages in a Spring Boot Application<\/h2>\n
                  We will write log messages in the controller class of the Spring Boot application. As I have mentioned earlier, we will write log messages against the SL4J API. The code of the controller class is this.<\/p>\n
                  IndexController.java<\/h4>\n
                  package guru.springframework.blog.controllers;\n\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.springframework.stereotype.Controller;\nimport org.springframework.web.bind.annotation.RequestMapping;\n\n@Controller\npublic class IndexController {\n    private final Logger logger = LoggerFactory.getLogger(this.getClass());\n    @RequestMapping(\"\/\")\n    String index(){\n        logger.debug(\"This is a debug message\");\n        logger.info(\"This is an info message\");\n        logger.warn(\"This is a warn message\");\n        logger.error(\"This is an error message\");\n        return \"index\";\n    }\n}<\/pre>\n
                  In the IndexController<\/code> class above, we used the LoggerFactory<\/code> and Logger<\/code> classes of SL4J to log debug, info, warn, and error messages.<\/p>\n
                  Configuring Logging in application.properties<\/h2>\n
                  In a Spring Boot application, you can externalize configuration to work with the same application code in different environments. The application.properties<\/strong> file is one of the many ways to externalize configuration. Let’s use it to externalize logging configuration.<\/p>\n
                  In the default structure of a Spring Boot web application, you can locate the application.properties<\/strong> file under the Resources<\/strong> directory. In the application.properties<\/strong> file, you can define log levels of Spring Boot, application loggers, Hibernate, Thymeleaf, and lots more. You can also define a log file to write log messages in addition to the console. An example of an application.properties<\/strong> file with logging configuration is this.<\/p>\n
                  logging.level.org.springframework.web=INFO\nlogging.level.guru.springframework.blogs.controllers=INFO\nlogging.level.org.hibernate=ERROR\nlogging.file=logs\/spring-boot-logging.log\nlog4j.logger.org.thymeleaf=DEBUG\n<\/pre>\n
                  When you run the main class, INFO<\/strong> and higher level log messages of Spring Boot startup are logged to the console and the logs\/spring-boot-logging.log<\/strong> file.
                  \n\"Spring<\/a><\/p>\n
                  Note<\/strong>: There is also a logging.path<\/strong> property to specify a path for a logging file. If you use it, Spring Boot creates a spring.log<\/strong> file in the specified path. However, you cannot specify both the logging.file<\/strong> and logging.path<\/strong> properties together. If specified together, Spring Boot will ignore both.<\/p>\n
                  Once the application starts, access it with the URL, http:\/\/localhost:8080<\/strong>. Spring Boot outputs INFO<\/strong> and higher level log messages of IndexController<\/strong> to the console and file.
                  \n                  \"Application<\/a><\/p>\n
                  Using a Log4J 2 Configuration File<\/h2>\n
                  Log4J 2 configuration through application.properties<\/strong> file might be sufficient for simple applications. But, enterprise applications have far more complex logging requirements. Log4J 2 supports advanced logging configurations through configuration files, such as properties, XML, JSON, and YAML. I have explained how to configure Log4J 2 using XML here<\/a>.<\/p>\n
                  In a Spring Boot application, you can specify a Log4J 2 XML configuration file as log4j2.xml<\/strong> or log4j2-spring.xml<\/strong> in the project classpath. The Spring Boot team however recommends using the -spring<\/strong> variant for your logging configuration. That is log4j2-spring.xml<\/strong> rather than log4j2.xml<\/strong>. If you use the standard log4j2.xml<\/strong> configuration, Spring Boot might not be able to completely control log initialization.<\/p>\n
                  The code of the log4j2-spring.xml<\/strong> file, is this.<\/p>\n
                  <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Configuration monitorInterval=\"60\">\n    <Properties>\n        <Property name=\"log-path\">applogs<\/Property>\n    <\/Properties>\n    <Appenders>\n        <Console name=\"Console-Appender\" target=\"SYSTEM_OUT\">\n            <PatternLayout>\n                <pattern>\n                    [%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n\n                <\/pattern>>\n            <\/PatternLayout>\n        <\/Console>\n        <File name=\"App-File-Appender\" fileName=\"${log-path}\/app_log.log\" >\n            <PatternLayout>\n                <pattern>\n                    [%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n\n                <\/pattern>\n            <\/PatternLayout>\n        <\/File>\n        <File name=\"SpringBoot-File-Appender\" fileName=\"${log-path}\/springboot_log.log\" >\n            <PatternLayout>\n                <pattern>\n                    [%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n\n                <\/pattern>\n            <\/PatternLayout>\n        <\/File>\n    <\/Appenders>\n    <Loggers>\n        <Logger name=\"org.springframework.web\" level=\"info\" additivity=\"false\">\n            <AppenderRef ref=\"SpringBoot-File-Appender\"\/>\n            <AppenderRef ref=\"Console-Appender\"\/>\n        <\/Logger>\n        <Logger name=\"guru.springframework.blog.controllers\" level=\"info\" additivity=\"false\">\n            <AppenderRef ref=\"App-File-Appender\"\/>\n            <AppenderRef ref=\"Console-Appender\"\/>\n         <\/Logger>\n        <Root>\n            <AppenderRef ref=\"Console-Appender\"\/>\n        <\/Root>\n    <\/Loggers>\n<\/Configuration><\/pre>\n
                  In the configuration code above:<\/p>\n