SpringBootへのログイン

1。概要

この短いチュートリアルでは、SpringBootで利用できる主なロギングオプションについて説明します。

Logbackの詳細については、A Guide to Logbackを参照してください。一方、Log4j2は、Intro to Log4j2 – Appenders、Layouts andFiltersで紹介されています。

2.初期設定

まず、SpringBootモジュールを作成しましょう。これを行うための推奨される方法は、SpringBootチュートリアルで説明するSpringInitializrを使用することです。

それでは、唯一のクラスファイルであるLoggingControllerを作成しましょう。

@RestController public class LoggingController { Logger logger = LoggerFactory.getLogger(LoggingController.class); @RequestMapping("/") public String index() { logger.trace("A TRACE Message"); logger.debug("A DEBUG Message"); logger.info("An INFO Message"); logger.warn("A WARN Message"); logger.error("An ERROR Message"); return "Howdy! Check out the Logs to see the output..."; } } 

Webアプリケーションをロードすると、// localhost:8080 /にアクセスするだけで、これらのロギング行をトリガーできるようになります。

3.ゼロ構成ログ

SpringBootは非常に役立つフレームワークです。これにより、構成設定の大部分を忘れることができます。構成設定の多くは、意見によって自動調整されます。

ロギングの場合、必須の依存関係はApache CommonsLoggingのみです。

Spring 5(Spring Boot 2.x)のSpring Frameworkのspring-jclモジュールによって提供されるため、Spring 4.x(Spring Boot 1.x)を使用する場合にのみインポートする必要があります。

Spring Boot Starter(ほとんどの場合)を使用している場合は、spring-jclのインポートについてまったく心配する必要はありません。これは、spring-boot-starter-webのようなすべてのスターターが、すでにspring-jclをプルしているspring-boot-starter-loggingに依存しているためです。

3.1。デフォルトのログバックログ

スターターを使用する場合、デフォルトではログバックがログに使用されます。

Spring Bootは、標準出力を読みやすくするために、パターンとANSIカラーで事前構成します。

アプリケーションを実行して// localhost:8080 /ページにアクセスし、コンソールで何が起こるかを見てみましょう。

ご覧のとおり、ロガーのデフォルトのログレベルはINFOに事前設定されています。つまり、TRACEメッセージとDEBUGメッセージは表示されません。

構成を変更せずにそれらをアクティブ化するために、コマンドラインで–debugまたは–trace引数を渡すことができます

java -jar target/spring-boot-logging-0.0.1-SNAPSHOT.jar --trace 

3.2。ログレベル

Spring Bootを使用すると、環境変数を介して、よりきめ細かいログレベル設定にアクセスすることできます。これを達成する方法はいくつかあります。

まず、VMオプション内でログレベルを設定できます。

-Dlogging.level.org.springframework=TRACE -Dlogging.level.com.baeldung=TRACE

または、Mavenを使用している場合は、コマンドラインからログ設定を定義できます

mvn spring-boot:run -Dspring-boot.run.arguments=--logging.level.org.springframework=TRACE,--logging.level.com.baeldung=TRACE

Gradleを使用する場合、コマンドラインからログ設定を渡すことができます。これには、bootRunタスクを設定する必要があります。

それが完了したら、アプリケーションを実行します。

./gradlew bootRun -Pargs=--logging.level.org.springframework=TRACE,--logging.level.com.baeldung=TRACE

冗長性を永続的に変更したい場合は、ここで説明するように、application.propertiesファイルで変更できます。

logging.level.root=WARN logging.level.com.baeldung=TRACE 

最後に、ロギングフレームワーク構成ファイルを使用して、ロギングレベルを永続的に変更できます。

Spring BootStarterはデフォルトでログバックを使用することを説明しました。2つの別々のパッケージのレベルを設定するLogback構成ファイルのフラグメントを定義する方法を見てみましょう。

ことを覚えておいて、パッケージのログレベルを複数回定義されている場合、上述したさまざまなオプションを使用するが、異なるログ・レベルで、最低レベルが使用されます。

したがって、Logback、Spring Boot、および環境変数を同時に使用してログレベルを設定すると、ログレベルは要求されたレベルの中で最も低いため、TRACEになります。

4.ログバック構成ログ

デフォルトの構成は便利ですが(たとえば、POCや簡単な実験中にゼロ時間で開始する場合)、日常のニーズには十分ではない可能性があります。

異なる色とログパターン、コンソールファイル出力の個別の仕様、および巨大なログファイルの生成を回避するための適切なローリングポリシー使用して、ログバック構成を含める方法を見てみましょう。

まず、他の多くのアプリケーション設定で一般的に使用されているapplication.propertiesを汚染するのではなく、ログ設定のみを処理できるソリューションを見つける必要があります。

クラスパス内のファイルの名前が次のいずれかである場合、SpringBootはデフォルト構成でファイルを自動的にロードします。

  • logback-spring.xml
  • logback.xml
  • logback-spring.groovy
  • logback.groovy

Spring recommends using the -spring variant over the plain ones whenever possible, as described here.

Let's write a simple logback-spring.xml:

      %black(%d{ISO8601}) %highlight(%-5level) [%blue(%t)] %yellow(%C{1.}): %msg%n%throwable     ${LOGS}/spring-boot-logger.log  %d %p %C{1.} [%t] %m%n    ${LOGS}/archived/spring-boot-logger-%d{yyyy-MM-dd}.%i.log   10MB               

And when we run the application, here's the output:

As we can see, it now logs TRACE and DEBUG messages, and the overall console pattern is both textually and chromatically different than before.

It also now logs on a file in a /logs folder created under the current path and archives it through a rolling policy.

5. Log4j2 Configuration Logging

While Apache Commons Logging is at the core, and Logback is the reference implementation provided, all the routings to the other logging libraries are already included to make it easy to switch to them.

In order to use any logging library other than Logback, though, we need to exclude it from our dependencies.

For every starter like this one (it's the only one in our example, but we could have many of them):

 org.springframework.boot spring-boot-starter-web  

we need to turn it into a skinny version, and (only once) add our alternative library, here through a starter itself:

 org.springframework.boot spring-boot-starter-web   org.springframework.boot spring-boot-starter-logging     org.springframework.boot spring-boot-starter-log4j2  

At this point, we need to place in the classpath a file named one of the following:

  • log4j2-spring.xml
  • log4j2.xml

We'll print through Log4j2 (over SLF4J) without further modifications.

Let's write a simple log4j2-spring.xml:

        %d %p %C{1.} [%t] %m%n                    

And when we run the application, here's the output:

As we can see, the output is quite different from the Logback one — a proof that we're fully using Log4j2 now.

In addition to the XML configuration, Log4j2 allows us to use also a YAML or JSON configuration, described here.

6. Log4j2 Without SLF4J

We can also use Log4j2 natively, without passing through SLF4J.

In order to do that, we simply use the native classes:

import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; // [...] Logger logger = LogManager.getLogger(LoggingController.class); 

We don't need to perform any other modification to the standard Log4j2 Spring Boot configuration.

We can now exploit the brand-new features of Log4j2 without getting stuck with the old SLF4J interface. But we're also tied to this implementation, and we'll need to rewrite our code when switching to another logging framework.

7. Logging With Lombok

In the examples we've seen so far, we've had to declare an instance of a logger from our logging framework.

This boilerplate code can be annoying. We can avoid it using various annotations introduced by Lombok.

We'll first need to add the Lombok dependency in our build script to work with it:

 org.projectlombok lombok 1.18.4 provided 

7.1. @Slf4j and @CommonsLog

SLF4J and Apache Commons Logging APIs allow us the flexibility to change our logging framework with no impact on our code.

And we can use Lombok's @Slf4j and @CommonsLog annotations to add the right logger instance into our class: org.slf4j.Logger for SLF4J and org.apache.commons.logging.Log for Apache Commons Logging.

To see these annotations in action, let's create a class similar to LoggingController but without a logger instance. We name it as LombokLoggingController and annotate it with @Slf4j:

@RestController @Slf4j public class LombokLoggingController { @RequestMapping("/lombok") public String index() { log.trace("A TRACE Message"); log.debug("A DEBUG Message"); log.info("An INFO Message"); log.warn("A WARN Message"); log.error("An ERROR Message"); return "Howdy! Check out the Logs to see the output..."; } }

Note that we've adjusted the snippet just a bit, using log as our logger instance. This is because adding the annotation @Slf4j automatically adds a field named log.

With Zero-Configuration Logging, the application will use underlying logging implementation Logback for logging. Similarly, Log4j2 implementation is used for logging with Log4j2-Configuration Logging.

We get the same behavior when we replace the annotation @Slf4j with @CommonsLog.

7.2. @Log4j2

We can use the annotation @Log4j2 to use Log4j2 directly. So, we make a simple change to LombokLoggingController to use @Log4j2 instead of @Slf4j or @CommonsLog:

@RestController @Log4j2 public class LombokLoggingController { @RequestMapping("/lombok") public String index() { log.trace("A TRACE Message"); log.debug("A DEBUG Message"); log.info("An INFO Message"); log.warn("A WARN Message"); log.error("An ERROR Message"); return "Howdy! Check out the Logs to see the output..."; } } 

Other than logging, there are other annotations from Lombok that help in keeping our code clean and tidy. More information about them is available in Introduction to Project Lombok, and we also have a tutorial on Setting Up Lombok With Eclipse and IntelliJ.

8. Beware of Java Util Logging

Spring Boot also supports JDK logging, through the logging.properties configuration file.

There are cases when it's not a good idea to use it, though. From the documentation:

There are known classloading issues with Java Util Logging that cause problems when running from an ‘executable jar'. We recommend that you avoid it when running from an ‘executable jar' if at all possible.

It's also a good practice when using Spring 4 to manually exclude commons-logging in pom.xml, to avoid potential clashes between the logging libraries. Spring 5 instead handles it automatically, so we don't need to do anything when using Spring Boot 2.

9. JANSI on Windows

While Unix-based operating systems such as Linux and Mac OS X support ANSI color codes by default, on a Windows console, everything will be sadly monochromatic.

Windows can obtain ANSI colors through a library called JANSI.

We should pay attention to the possible class loading drawbacks, though.

We must import and explicitly activate it in the configuration as follows:

Logback:

  true  [%thread] %highlight(%-5level) %cyan(%logger{15}) - %msg %n     

Log4j2:

ANSI escape sequences are supported natively on many platforms but are not by default on Windows. To enable ANSI support, add the Jansi jar to our application and set property log4j.skipJansi to false. This allows Log4j to use Jansi to add ANSI escape codes when writing to the console.

Note: Prior to Log4j 2.10, Jansi was enabled by default. The fact that Jansi requires native code means that Jansi can only be loaded by a single class loader. For web applications, this means the Jansi jar has to be in the web container's classpath. To avoid causing problems for web applications, Log4j no longer automatically tries to load Jansi without explicit configuration from Log4j 2.10 onward.

It's also worth noting:

  • The layout documentation page contains useful Log4j2 JANSI informations in the highlight{pattern}{style} section.
  • While JANSI can color the output, Spring Boot's Banner (native or customized through the banner.txt file) will stay monochromatic.

10. Conclusion

SpringBootプロジェクト内から主要なロギングフレームワークとインターフェイスする主な方法を見てきました。

また、各ソリューションの主な利点と落とし穴についても説明しました。

いつものように、完全なソースコードはGitHubで入手できます。