Protokollierungskonfiguration in Spring Boot

Die Protokollierung ist ein wichtiger Bestandteil jeder Anwendung. Die Überprüfung der Protokolle ist der erste Schritt zur Fehlerbehebung. Daher ist es wichtig, die richtigen Informationen zu protokollieren. Gleichzeitig kann eine übermäßige Protokollierung zu einer überfüllten Protokolldatei führen, die wiederum viel Speicherplatz beansprucht. In einigen Anwendungen verwenden Entwickler synchrone Protokollierung, was sich auf die Leistung der Anwendung auswirken kann. Protokollierungsbibliotheken wie Logback und Log4j2 bieten asynchrone Protokollierung.

  • Lesen Sie auch: Spring Boot-Tutorials

Spring Boot bietet hervorragende Unterstützung für die Protokollierung und bietet viele Hooks, um diese zu konfigurieren. In diesem Artikel sehen wir uns die Standardunterstützung für die Protokollierung in Spring Boot an und verwenden dann die Hooks, also die Spring-Eigenschaften, um die Protokollierung zu konfigurieren. Am Ende dieses Artikels werden Sie mit der Protokollierungskonfiguration in Spring-Boot-Anwendungen vertraut sein.

Tutorial zur Protokollierungskonfiguration mit Spring Boot

Erstellen Sie ein Spring Boot-Projekt mit Maven

Lassen Sie uns zunächst ein einfaches Maven-Projekt erstellen und aktualisieren pom.xml mit dem folgenden Code:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>net.javabeat</groupId>
<artifactId>springboot-logging</artifactId>
<version>0.1</version>
<name>SpringBoot Logging</name>
<properties>
<java.version>1.8</java.version>
<start-class>net.javabeat.SpringBootLoggingDemo</start-class>
</properties>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

Die Abhängigkeit spring-boot-starter beinhaltet die Abhängigkeiten für die Protokollierung spring-boot-starter-loggingDaher müssen wir die Protokollierungsabhängigkeit nicht erneut hinzufügen. Der spring-boot-starter-logging Enthält SLF4J- und Logback-Abhängigkeiten mit entsprechenden SLF4J-Wrappern für andere Protokollierungsbibliotheken.

Standardprotokollierungsunterstützung in Spring Boot

Im Spring Boot-Referenzdokument heißt es:

Wenn Sie die „Starter-POMs“ verwenden, wird standardmäßig Logback für die Protokollierung verwendet. Ein entsprechendes Logback-Routing ist ebenfalls enthalten, um sicherzustellen, dass alle abhängigen Bibliotheken, die Java Util Logging, Commons Logging, Log4J oder SLF4J verwenden, ordnungsgemäß funktionieren.

Lasst uns erschaffen SpringBootLoggingDemo Klasse in net.javabeat Paket, das der Ausgangspunkt für unsere Bewerbung sein wird. Standardmäßig wird die Protokollierung in die Konsole geschrieben, wobei ein festes Protokollierungsformat verwendet wird, das von Logback verwendet wird, wie unten gezeigt:

09:59:03.086 [net.javabeat.SpringBootLoggingDemo.main()] ERROR net.javabeat.SpringBootLoggingDemo - Message logged at ERROR level

Das obige Protokoll enthält folgende Teile:

  • Zeit mit Millisekundengenauigkeit
  • Name des Threads in eckigen Klammern ([])
  • Protokollebene
  • Logger-Name, im Allgemeinen der Kürze halber der Klassenname gekürzt
  • Tatsächliche Protokollnachricht
  • Die von Logback konfigurierte Standardprotokollebene ist DEBUG dh alle Nachrichten, die unter protokolliert werden ERROR, WARN, INFO Und DEBUG werden auf der Konsole ausgedruckt. Lassen Sie uns das schaffen SpringBootLoggingDemo Klasse mit einem Logger und Protokollmeldungen auf den Ebenen ERROR, WARN, INFO und DEBUG, wie unten gezeigt:

    package net.javabeat;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringBootLoggingDemo {
    
    private static final Logger logger = LoggerFactory.getLogger(SpringBootLoggingDemo.class);
    
    public static void main(String[] args) {
    SpringApplication springApplication = new SpringApplication(new Object[]{SpringBootLoggingDemo.class});
    springApplication.run(args);
    
    logger.error("Message logged at ERROR level");
    logger.warn("Message logged at WARN level");
    logger.info("Message logged at INFO level");
    logger.debug("Message logged at DEBUG level");
    
    }
    }
    

    Führen Sie die Anwendung mit dem folgenden Befehl aus: mvn spring-boot:run um die auf der Konsole gedruckten Protokollmeldungen wie gezeigt anzuzeigen:

    10:01:40.996 [net.javabeat.SpringBootLoggingDemo.main()] ERROR net.javabeat.SpringBootLoggingDemo - Message logged at ERROR level
    10:01:40.996 [net.javabeat.SpringBootLoggingDemo.main()] WARN  net.javabeat.SpringBootLoggingDemo - Message logged at WARN level
    10:01:40.996 [net.javabeat.SpringBootLoggingDemo.main()] INFO  net.javabeat.SpringBootLoggingDemo - Message logged at INFO level
    10:01:40.996 [net.javabeat.SpringBootLoggingDemo.main()] DEBUG net.javabeat.SpringBootLoggingDemo - Message logged at DEBUG level
    

    Ändern der Standardkonfiguration durch Bereitstellung von logback.xml

    Lassen Sie uns nun die Standard-Logback-Konfiguration ändern, indem wir eine logback.xml-Konfigurationsdatei bereitstellen, wie unten gezeigt:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    <appender name="STDOUT"  >
    <!-- Log message format -->
    <encoder>
    <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
    </pattern>
    </encoder>
    </appender>
    
    <!-- Setting the root level of logging to INFO -->
    <root level="info">
    <appender-ref ref="STDOUT" />
    </root>
    </configuration>
    

    Die obige Konfiguration bewirkt Folgendes:

    • Richten Sie mit ConsoleAppender einen Appender STDOUT ein, der auf der Konsole druckt
    • Geben Sie dem Appender ein Muster zum Erstellen der Protokollnachricht an
    • Richten Sie einen Root-Logger ein, der mithilfe des STDOUT-Appenders alle Nachrichten über der INFO-Ebene protokolliert

    Wir müssen diese logback.xml im Klassenpfad der Anwendung platzieren, damit Spring Boot die Konfiguration auswählen kann. Ich habe dies wie unten gezeigt in src/main/resources abgelegt:
    Spring-Boot-ProtokollierungLassen Sie uns die Anwendung erneut ausführen mit mvn spring-boot:run und nur das sehen ERROR, WARN, INFO werden protokolliert und das eine DEBUG wird nicht wie unten gezeigt protokolliert:

    14:04:23.805 [net.javabeat.SpringBootLoggingDemo.main()] ERROR net.javabeat.SpringBootLoggingDemo - Message logged at ERROR level
    14:04:23.808 [net.javabeat.SpringBootLoggingDemo.main()] WARN  net.javabeat.SpringBootLoggingDemo - Message logged at WARN level
    14:04:23.809 [net.javabeat.SpringBootLoggingDemo.main()] INFO  net.javabeat.SpringBootLoggingDemo - Message logged at INFO level
    

    Dies war eine einfache logback.xml-Konfiguration. Sehen wir uns an, wie wir es konfigurieren können, um unterschiedliche Protokollebenen für verschiedene Java-Pakete in der Anwendung festzulegen. Dazu erstellen wir zunächst zwei Klassen: TestModel.java In net.javabeat.model Und TestService.java In net.javabeat.service wie unten gezeigt:

    TestModel.java

    package net.javabeat.model;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class TestModel {
    private static final Logger logger = LoggerFactory.getLogger(TestModel.class);
    
    public TestModel(){
    logger.debug("Log message at DEBUG level from TestModel constructor");
    logger.info("Log message at INFO level from TestModel constructor");
    }
    }
    

    TestService.java

    package net.javabeat.service;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class TestService {
    
    private Logger logger = LoggerFactory.getLogger(TestService.class);
    
    public void service(){
    logger.info("Message at INFO level from TestService.service()");
    logger.warn("Message at WARN level from TestService.service()");
    }
    }
    

    Die Projektstruktur mit diesen neuen Dateien sieht wie folgt aus:
    Spring Boot-Logback

    Wir werden die Protokollebene für das Paket net.javabeat.service auf WARN und für das Paket net.javabeat.model auf INFO setzen, wie unten gezeigt:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    <appender name="STDOUT"  >
    <!-- Log message format -->
    <encoder>
    <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
    </appender>
    
    <!-- Setting the logging level to WARN for code in net.javabeat.service -->
    <logger name="net.javabeat.service" level="WARN" />
    
    <!-- Setting the logging level to INFO for code in net.javabeat.model -->
    <logger name="net.javabeat.model" level="INFO" />
    
    <!-- Setting the root level of logging to INFO -->
    <root level="info">
    <appender-ref ref="STDOUT" />
    </root>
    </configuration>
    

    Wir müssten das aktualisieren SpringBootLoggingDemo class und fügen Sie die folgenden Zeilen hinzu, bevor Sie eine neue Instanz von erstellen SpringApplication:

    TestModel model = new TestModel();
    TestService service = new TestService();
    service.service();

    Wenn wir nun die Anwendung ausführen, erhalten wir die folgende Ausgabe:

    17:36:07.616 [net.javabeat.SpringBootLoggingDemo.main()] ERROR net.javabeat.SpringBootLoggingDemo - Message logged at ERROR level
    17:36:07.632 [net.javabeat.SpringBootLoggingDemo.main()] WARN  net.javabeat.SpringBootLoggingDemo - Message logged at WARN level
    17:36:07.632 [net.javabeat.SpringBootLoggingDemo.main()] INFO  net.javabeat.SpringBootLoggingDemo - Message logged at INFO level
    17:36:07.632 [net.javabeat.SpringBootLoggingDemo.main()] INFO  net.javabeat.model.TestModel - Log message at INFO level from TestModel constructor
    17:36:07.632 [net.javabeat.SpringBootLoggingDemo.main()] WARN  net.javabeat.service.TestService - Message at WARN level from TestService.service()
    

    Sie können beobachten, dass für TestModel die Nachricht auf DEBUG-Ebene nicht protokolliert wurde und für TestService die Nachricht auf INFO-Ebene nicht protokolliert wurde.

    Senden der Protokollnachrichten an eine Datei

    In diesem Tutorial verwende ich die logback.xml als Protokollierungskonfiguration. Spring Boot verwendet standardmäßig das Logback als Standardprotokollierungsimplementierung, wenn Sie keine anderen Implementierungen angeben. Wenn Sie die Protokolldateien in eine Datei schreiben möchten, diese aber nicht verwenden möchten logback.xml In der Datei für die Konfigurationen können Sie die Spring-Boot-Eigenschaften verwenden logging.path oder logging.file um den Speicherort der Protokolldateien anzugeben.

    Spring Boot sucht nach den beiden oben genannten Eigenschaften. Wenn diese nicht angegeben sind, werden die Protokollmeldungen an den Konsolen-Appender gesendet. Andernfalls werden die Protokollmeldungen an die durch diese Eigenschaften angegebene Datei gesendet.

    Eigenschaften der Spring-Boot-Protokollierung

    Eigenschaften der Spring-Boot-Protokollierung

    Schauen wir uns nun an, wie Sie die Protokollmeldung zum Drucken der Protokollmeldung in den Dateien verwenden. Bisher haben wir gesehen, wie die Protokollmeldungen auf der Konsole gedruckt wurden. Sehen wir uns nun an, wie diese in eine Datei geschrieben werden können. Wir müssen die Konfiguration von logback.xml aktualisieren, um einen neuen Appender zum Schreiben in die Datei hinzuzufügen, und diesen Appender dann in den in der Konfigurationsdatei definierten Loggern verwenden, wie unten gezeigt:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    <appender name="STDOUT"  >
    <!-- Log message format -->
    <encoder>
    <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
    </appender>
    <!-- Ned appender to write to file -->
    <appender name="FILE"  >
    <!-- Name of the file where the log messages are written -->
    <file>myApp.log</file>
    <encoder>
    <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
    </appender>
    <logger name="net.javabeat.service" level="WARN">
    <appender-ref ref="FILE" />
    </logger>
    <logger name="net.javabeat.model" level="INFO">
    <appender-ref ref="FILE" />
    </logger>
    
    <!-- Setting the root level of logging to INFO -->
    <root level="info">
    <appender-ref ref="FILE" />
    </root>
    </configuration>
    

    Wenn Sie nun die Anwendung ausführen, werden alle Protokollmeldungen in die Datei umgeleitet myApp.log im aktuellen Verzeichnis vorhanden.

    Verwendung der Standard-Logback-Konfiguration base.xml

    Bisher haben wir weder die Spring Boot-Funktionen noch die darin enthaltenen Standardeinstellungen genutzt. In diesem Abschnitt zeigen wir Ihnen, wie wir die Logback-Konfiguration base.xml nutzen können. Base.xml richtet die folgenden Dinge ein:

    • Verknüpfen der Federeigenschaften – logging.file, logging.path – mit der Logback-Konfiguration
    • Einrichten von Konsolen- und Datei-Appendern
    • Protokollebenen für einige Pakete festlegen

    Lassen Sie uns die Konfigurationsdatei logback.xml mit der folgenden Konfiguration aktualisieren:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    <logger name="net.javabeat.service" level="WARN"></logger>
    <logger name="net.javabeat.model" level="INFO"></logger>
    </configuration>
    

    Und hinzufügen application.properties Datei mit einer Eigenschaft logging.file mit dem Namen der Datei wie gezeigt: logging.file=demo_logging.log. Das Logging wird nun sowohl in die Konsole als auch in die Datei geschrieben. Lassen Sie uns dies überprüfen, indem wir die Anwendung mit ausführen mvn spring-boot:run um die folgenden Protokollmeldungen auf der Konsole und in der Datei demo_logging.log auszudrucken:

    ...
    2015-08-18 19:35:09.725 ERROR 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at ERROR level
    2015-08-18 19:35:09.725  WARN 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at WARN level
    2015-08-18 19:35:09.725  INFO 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at INFO level
    2015-08-18 19:35:09.726  INFO 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.model.TestModel             : Log message at INFO level from TestModel constructor
    2015-08-18 19:35:09.727  WARN 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.service.TestService         : Message at WARN level from TestService.service()
    ...
    
    C:\Users\Mohamed\workspace\springboot-logging>more demo_logging.log
    ...
    2015-08-18 19:35:09.725 ERROR 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at ERROR level
    2015-08-18 19:35:09.725  WARN 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at WARN level
    2015-08-18 19:35:09.725  INFO 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.SpringBootLoggingDemo       : Message logged at INFO level
    2015-08-18 19:35:09.726  INFO 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.model.TestModel             : Log message at INFO level from TestModel constructor
    2015-08-18 19:35:09.727  WARN 7316 --- [net.javabeat.SpringBootLoggingDemo.main()] net.javabeat.service.TestService         : Message at WARN level from TestService.service()
    

    Sie sehen, dass wir mit einer minimalen logback.xml dank der von Springboot bereitgestellten Standardeinstellungen viel mehr erreicht haben. Den Code für diesen Artikel finden Sie hier Hier.

    Abschluss

    Ich hoffe, dass dieses Tutorial genügend Einblick in die Verwendung des Protokollierungsmechanismus in der Spring Boot-Anwendung gegeben hat. Außerdem habe ich über die Standardprotokollierungsunterstützung in den Spring Boot-Anwendungen geschrieben und darüber, wie man diese durch Ändern der Datei logback.xml außer Kraft setzt. Wenn Sie Fragen zur Protokollierungskonfiguration in Spring Boot haben, schreiben Sie diese bitte in den Kommentarbereich.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen