Protokollierung mit Log4j2: Ein Leitfaden für Java-Entwickler

Einer der wichtigsten Teile des Softwareentwicklungsprozesses ist die richtige Protokollierung. Da es viele verschiedene Java-Protokollierungs-Frameworks gibt, ist es wichtig, eines zu wählen, das einfach zu bedienen ist. Gleichzeitig sollte das Framework Ihrer Wahl leistungsstark und erweiterbar sein und eine individuelle Anpassung ermöglichen. Log4j2 ist eine kostenlose Java-Protokollierungsbibliothek, die alle diese Kriterien erfüllt.

Durch die Integration von Log4j2 in eine beliebige Anwendung werden Optionen wie erweiterte Filterung, Java 8 Lambda-Unterstützung, Property Lookups und benutzerdefinierte Protokollebenen freigeschaltet. Lassen Sie uns einen Blick darauf werfen, wie Sie Log4j2 in Ihre Projekte einbinden können und welche Funktionen Ihnen dabei helfen, den Überblick zu behalten.

Was ist Log4j2?

Logging ist eine Methode zur Erfassung nützlicher Informationen, die als Logs bezeichnet werden und später referenziert und analysiert werden können. Sie können die Protokolle verwenden, um Anwendungscode schnell zu debuggen. Anwendungsprotokolle helfen, den Codefluss zu verstehen und Produktionsprobleme und Fehler zu beheben.

Neben den diagnostischen Anwendungsfällen werden Protokolle auch für Audit-Zwecke verwendet, z.B. um zu verfolgen, ob eine Benachrichtigung erfolgreich an den Benutzer gesendet wurde oder nicht.

Log4j2 ist eine der beliebtesten Java-Protokollierungsbibliotheken. Sie ist ein Nachfolger der sehr einflussreichen Log4j-Bibliothek. Log4j2 wurde von der Apache Software Foundation entwickelt und ist Teil der Apache Logging Services. Es handelt sich um freie und quelloffene Software (FOSS), die unter der Apache License, Version 2.0, vertrieben wird.

Log4j2 baut auf der soliden Grundlage des ursprünglichen Log4j auf. Die Verwendung eines Loggers hat gegenüber den einfachen Druckanweisungen von System.out.println() einige Vorteile. Dazu gehört die Kontrolle darüber, welche Meldungen angezeigt werden sollen, während andere Protokollmeldungen vermieden werden. Ordnungsgemäße Protokolle sind in einer Produktionsumgebung, in der keine Debugger zur Verfügung stehen, von entscheidender Bedeutung.

Wie fügen Sie Log4j2 zu Ihrem Projekt hinzu?

Es gibt mehrere Möglichkeiten, Log4j2 zu Ihrem Java-Projekt hinzuzufügen. Es ist ratsam, Java 8 oder höher zu verwenden, um alle Funktionen von Log4j2 nutzen zu können.

Lassen Sie uns die verschiedenen Methoden besprechen, mit denen Sie Log4j2 je nach Ihren Anforderungen hinzufügen können.

Hinzufügen von Log4j2 zu Projekten, die Apache Maven verwenden

Wenn Ihr Projekt Apache Maven als Build-System verwendet, müssen die Log4j2-Abhängigkeiten zur pom.xml-Datei hinzugefügt werden.

<dependencies>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 <version>2.20.0</version>
 </dependency>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 <version>2.20.0</version>
 </dependency>
</dependencies&gt

Um es einfacher zu machen, dieselbe Version über verschiedene Artefakte hinweg zu pflegen, verfügt Log4j2 über eine Bill of Material (BOM) pom.xml-Datei. Wenn Sie diese unter Ihrer Abhängigkeitsverwaltung hinzufügen, müssen Sie die Versionen nicht einzeln hinzufügen.

<!-- Fügen Sie die Stückliste zum dependencyManagement hinzu -->

<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-bom</artifactId>
 <version>2.20.0</version>
 <scope>import</scope>
 <type>pom</type>
 </dependency>
 </dependencies>
</dependencyManagement>

<!-- Sobald die Stückliste hinzugefügt ist, werden die Versionen nicht mehr benötigt -->

<dependencies>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 </dependency>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 </dependency>
</dependencies&gt

Hinzufügen von Log4j2 zu Projekten mit Apache Gradle

Falls Sie Apache Gradle als Build-Tool verwenden, können Sie die Log4j2-Abhängigkeiten zu Ihrer build.gradle-Datei hinzufügen.

abhängigkeiten {
 Implementierung 'org.apache.logging.log4j:log4j-api:2.20.0'
 Implementierung 'org.apache.logging.log4j:log4j-core:2.20.0'
}

Wenn Sie mit Gradle Version 5.0 oder höher arbeiten, haben Sie die Möglichkeit, die Log4j2 Maven Bill Of Materials (BOM) zu importieren, um konsistente Abhängigkeitsversionen zu erhalten. Dies können Sie erreichen, indem Sie Folgendes zu Ihrer build.gradle Datei hinzufügen.

dependencies {
 implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0')

 implementation 'org.apache.logging.log4j:log4j-api'
 runtimeOnly 'org.apache.logging.log4j:log4j-core'
}

Für Gradle Versionen 2.8-4.10 gibt es keine Möglichkeit, die Maven BOM direkt zu importieren. Sie müssen ein zusätzliches Plugin für die Funktionalität der Abhängigkeitsverwaltung hinzufügen.

plugins {
 id 'io.spring.dependency-management' version '1.0.15.RELEASE'
}

dependencyManagement {
 imports {
 mavenBom 'org.apache.logging.log4j:log4j-bom:2.20.0'
 }
}

dependencies {
 implementation 'org.apache.logging.log4j:log4j-api'
 runtimeOnly 'org.apache.logging.log4j:log4j-core'
}

Hinzufügen von Log4j2 zu Standalone-Anwendungen ohne Build-Tool

Wenn Ihr Projekt nicht über ein Build-Tool verfügt, können Sie die erforderliche Artefaktversion von Log4j2 von der offiziellen Log4j2 Download-Seite herunterladen.

Sobald Sie sie heruntergeladen haben, müssen Sie sicherstellen, dass der Klassenpfad Ihrer Anwendung die folgenden Jars enthält.

• log4j-api-2.20.0.jar
• log4j-core-2.20.0.jar

Was sind die Komponenten von Log4j2?

Um die Funktionen von Log4j2 zu verstehen und seine Möglichkeiten voll ausschöpfen zu können, ist es wichtig zu verstehen, wie Log4j2 funktioniert. Unter der Oberfläche besteht Log4j2 aus mehreren Bausteinen. Lassen Sie uns einen nach dem anderen besprechen.

#1. LoggerContext

Der LoggerContext ist die zentrale Einheit des Logging-Systems. Er enthält alle Logger, die in der Anwendung angefordert werden. Außerdem enthält er einen Verweis auf die Konfiguration.

#2. Konfiguration

Die Konfiguration enthält alle Informationen, die für das Protokollierungssystem erforderlich sind. Dazu gehören die Logger, Appenders, Filter und mehr. In Log4j2 können Sie die Konfiguration in verschiedenen Dateiformaten wie XML, JSON und YAML oder auch programmatisch über die Log4j2 API definieren.

Bei jeder Änderung einer Eigenschaft in der Konfiguration erfolgt ein automatisches Neuladen. Ein Neustart der Anwendung ist daher nicht erforderlich.

#3. Logger

Die Hauptkomponente des Log4j2-Systems ist der Logger. Logger werden innerhalb des Anwendungscodes mit der Anweisung LogManager.getLogger() abgerufen und zur Erzeugung von Protokollen verwendet. Logmeldungen können in verschiedenen Schweregraden erzeugt werden, z.B. debug, info, warn, error und fatal.

#4. LoggerConfig

Die LoggerConfig ist für das Verhalten eines bestimmten Loggers verantwortlich. Sie definiert das Verhalten und die Einstellungen für die Protokollierung von Ereignissen, die von diesem bestimmten Logger erzeugt werden. Sie ermöglicht die Konfiguration verschiedener Protokollierungsstufen, die Einrichtung von Appendern und die Anwendung von Filtern.

#5. Filter

Mit Hilfe von Filtern können Sie in Log4j2 Protokollereignisse selektiv verarbeiten. Filter werden auf der Grundlage bestimmter Kriterien angewendet. Sie können diese Filter auf Logger oder Appenders anwenden. Filter steuern, welche Protokollereignisse die Protokollierungspipeline zur weiteren Verarbeitung durchlaufen dürfen. Mit Hilfe von Filtern kann das Protokollierungsverhalten fein abgestimmt werden, um sicherzustellen, dass nur die relevanten Protokolle verarbeitet werden.

#6. Absender

Das Ziel jeder Protokollnachricht wird durch den Appender bestimmt. Ein einzelner Logger kann mehrere Appenders haben. Ein Log-Ereignis wird an alle Appenders für den jeweiligen Logger gesendet. Log4j2 verfügt über eine Vielzahl vorkonfigurierter Appenders. Der ConsoleAppender wird beispielsweise verwendet, um Meldungen auf der Konsole zu protokollieren, und der FileAppender, um Meldungen in eine Datei auszugeben. Jeder Appender benötigt ein eigenes Layout, das festlegt, wie die endgültige Protokollnachricht aussehen soll.

#7. Layout

In Log4j2 wird das Layout verwendet, um festzulegen, wie die endgültige Protokollnachricht aussehen soll. Ein Layout ist mit einem Appender verbunden. Während ein Appender das Ausgabeziel festlegt, beschreibt das Layout, wie die Nachricht ausgegeben werden soll.

Die 5 wichtigsten Funktionen von Log4j2

Log4j2 ist sehr funktionsreich und hebt sich dadurch von anderen verfügbaren Java-Protokollierungs-Frameworks ab. Von asynchronen Loggern bis hin zur Unterstützung von Java 8 Lambdas – Log4j2 ist anderen überlegen. Lassen Sie uns einige der bemerkenswerten Funktionen dieses Frameworks besprechen.

#1. Erweiterung der Funktionalitäten durch Plugins

In Log4j 1.x waren für die Erstellung von Erweiterungen eine Menge Codeänderungen erforderlich. Log4j2 löst das Problem der Erweiterbarkeit durch die Einführung des Plugin-Systems.

Sie können ein neues Plugin deklarieren, indem Sie die @Plugin-Annotation in Ihrer Klasse verwenden. Mit Hilfe von Plugins können Sie Ihre eigenen Komponenten wie Filter und Appenders erstellen. Auch Komponenten von Drittanbietern lassen sich leicht zur Bibliothek hinzufügen.

#2. Unterstützung von Java 8 Lambda

Mit der Veröffentlichung von Log4j2 Version 2.4 wurde die Unterstützung für Java 8 Lambda-Ausdrücke eingeführt. Mit Lambda-Ausdrücken können Sie Ihre Logging-Logik inline definieren. Dies reduziert die Notwendigkeit von mehrzeiligen Prüfungen oder anonymen inneren Klassen. Außerdem wird so sichergestellt, dass teure Methoden nicht unnötig ausgeführt werden. Dadurch wird nicht nur der Code sauberer und leichter lesbar, sondern auch der System-Overhead wird reduziert.

Betrachten wir ein Beispiel, bei dem Sie das Ergebnis einer teuren Operation protokollieren, aber nur, wenn die Debug-Ebene aktiviert ist. Bevor es die Unterstützung für Lambdas gab, wurde dies mit dem unten stehenden Code durchgeführt:

if (logger.isDebugEnabled()) {
 logger.debug("Die Ausgabe der angegebenen Operation ist: {}", expensiveOperation());
}

Mehrere solcher Anwendungsfälle würden unnötigerweise bedingte Prüfungen einführen. Mit Log42 kann die gleiche Aktion jedoch wie folgt durchgeführt werden:

logger.debug("Die Ausgabe der angegebenen Operation ist: {}", () -> expensiveOperation()

Die Methode exprensiveOperation() wird nur ausgewertet, wenn die Debug-Ebene aktiviert ist. Es sind keine expliziten Überprüfungen erforderlich.

#3. Asynchrone Logger

Jedes Protokollereignis ist eine E/A-Operation, die den System-Overhead erhöht. Um dies abzumildern, führt Log4j2 asynchrone Logger ein, die in einem vom Anwendungsthread getrennten Thread laufen. Wenn Sie asynchrone Logger verwenden, erhält der aufrufende Thread nach dem Aufruf der Methode logger.log() sofort wieder die Kontrolle.

Dadurch kann er mit der Anwendungslogik fortfahren, anstatt auf den Abschluss des Protokollierungsereignisses zu warten. Durch die Nutzung dieses asynchronen Verhaltens wird ein höherer Protokollierungsdurchsatz erreicht. Sie können entweder alle Logger standardmäßig asynchron machen oder eine Mischung aus synchronem und asynchronem Verhalten verwenden.

#4. Garbage-free Logging

In Java ist die Garbage Collection der Prozess, durch den nicht verwendete Objekte in der Anwendung automatisch gelöscht werden. Obwohl Sie sich nicht manuell um diesen Vorgang kümmern müssen, ist die Garbage Collection mit einem gewissen Overhead verbunden.

Wenn Ihre Anwendung in kurzer Zeit zu viele Objekte erstellt, kann der Garbage Collection-Prozess mehr Systemressourcen als nötig in Anspruch nehmen. Mehrere Protokollierungsbibliotheken, darunter auch frühere Versionen von Log4j, erstellen während des Protokollierungsprozesses eine Menge temporärer Objekte. Die erhöhte Belastung des Garbage Collectors wirkt sich dann auf die Systemleistung aus.

Seit Version 2.6 läuft Log4j2 im “garbage-free”-Modus. Dies ist das Standardverhalten. Daher werden Objekte wiederverwendet und die Erstellung von temporären Objekten wird stark reduziert.

Die folgenden Bilder zeigen, wie Log4j2 Version 2.6 das Problem der unnötigen Objekte im Vergleich zu Log4j2 Version 2.5 entschärft.

#5. Nachschlagen

In log4j2 können Sie Ihren Protokollen mithilfe von Lookups kontextbezogene Informationen hinzufügen. Damit können Sie Daten aus verschiedenen Quellen hinzufügen, z.B. Systemeigenschaften, Umgebungsvariablen oder benutzerdefinierte Werte. So können Sie relevante Informationen einfügen, die dynamisch abgerufen werden und die Protokolle nützlicher machen.

Nehmen wir ein Beispiel, bei dem Sie die Sitzungs-ID des Benutzers mit allen Protokollzeilen protokollieren möchten. Damit könnten Sie nach allen Protokollen suchen, die einer Sitzungsnummer entsprechen.

Um dies zu erreichen, müssten Sie die Sitzungsnummer explizit einzeln hinzufügen, was schwierig zu pflegen ist. Außerdem könnten Sie bald vergessen, sie hinzuzufügen, wodurch wertvolle Informationen verloren gehen.

logger.info("Die Benutzerdaten wurden für die Sitzungsnummer {} abgeholt", sessionId);
...
logger.info("Die Transaktion wurde für die Sitzungsnummer {} verarbeitet", sessionId);
...
logger.info("Die Anfrage wurde für die Sitzungsnummer {} erfolgreich verarbeitet", sessionId);

Eine bessere Möglichkeit wäre die Verwendung der Context Map Lookup. Die Sitzungs-ID kann dem Thread-Kontext im Anwendungscode hinzugefügt werden. Der Wert kann dann in der Log4j2-Konfiguration verwendet werden. Damit entfällt die Notwendigkeit, sie in den Protokollnachrichten explizit zu erwähnen.

ThreadContext.put("sessionId", sessionId);

Sobald der Wert hinzugefügt wurde, kann er in Lookup mit dem Schlüsselwort ctx verwendet werden.

<File name="Application" fileName="application.log">
 <PatternLayout>
 <pattern>%d %p %c{1.} [%t] $${ctx:sessionId} %m%n</pattern>
 </PatternLayout>
</File&gt

Wie erstellt man benutzerdefinierte Log Levels in Log4j2?

Log-Levels in Log4j2 werden verwendet, um Log-Ereignisse nach ihrem Schweregrad oder ihrer Wichtigkeit zu kategorisieren. Sie können die Protokollstufe steuern, wenn Sie eine Nachricht im Anwendungscode protokollieren.

Zum Beispiel fügt logger.debug() den DEBUG-Level hinzu. Dementsprechend fügt logger.error() die Stufe ERROR hinzu. Dies bestimmt, welche Meldungen letztendlich in der Ausgabe erscheinen. Sie können die Protokollstufe in der Konfigurationsdatei konfigurieren.

Die vorkonfigurierten Log-Levels in Log4j2 und ihre entsprechenden Werte sind im Folgenden aufgeführt.

Wenn die Protokollstufe auf einen bestimmten Wert eingestellt ist, werden alle Protokollzeilen für den entsprechenden Wert und die darüber liegenden (mit geringerem Wert) ausgegeben. Die anderen werden ignoriert.

Wenn Sie beispielsweise die Protokollstufe auf WARN setzen, werden die Meldungen WARN, ERROR und FATAL angezeigt. Jede Protokollzeile mit einer anderen Stufe wird ignoriert. Dies ist besonders nützlich, wenn Sie denselben Code in verschiedenen Umgebungen ausführen.

Wenn Sie den Code in Ihrer Entwicklungsumgebung ausführen, sollten Sie die Protokollstufe auf INFO oder DEBUG einstellen. Dadurch können Sie mehr Protokolle sehen und den Entwicklungsprozess unterstützen. Wenn Sie den Code jedoch in einer Produktionsumgebung ausführen, sollten Sie ihn auf ERROR setzen. So können Sie sich auf die Suche nach dem Problem konzentrieren, falls eine Anomalie auftritt, und müssen sich nicht durch unnötige Protokollzeilen wühlen.

Es kann vorkommen, dass Sie zusätzlich zu den vorkonfigurierten Log-Ebenen Ihre eigene benutzerdefinierte Log-Ebene hinzufügen möchten. Mit Log4j2 können Sie das ganz einfach tun. Sehen wir uns an, wie Sie Ihre eigenen Log Levels hinzufügen und in Ihrer Anwendung verwenden können.

#1. Hinzufügen von benutzerdefinierten Log Levels über die Konfigurationsdatei

Sie können benutzerdefinierte Log Levels hinzufügen, indem Sie sie in der Konfigurationsdatei deklarieren.

Im folgenden Beispiel wurde eine benutzerdefinierte Protokollstufe namens NOTICE mit einem Wert von 450 definiert. Damit liegt sie zwischen INFO (mit einem Wert von 400) und DEBUG (mit einem Wert von 500). Das bedeutet, dass, wenn die Stufe auf NOTICE eingestellt ist, INFO-Meldungen protokolliert werden, DEBUG-Meldungen jedoch übersprungen werden.

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
 <CustomLevels>
 <CustomLevel name="NOTICE" intLevel="450" />
 </CustomLevels>
 
 <Appenders>
 <File name="MyFile" fileName="logs/app.log">
 <PatternLayout pattern="%d %-7level %logger{36} - %msg%n"/>
 </File>
 </Appenders>
 <Logger>
 <Root level="trace">
 <AppenderRef ref="MyFile" level="NOTICE" />
 </Root>
 </Loggers>
</Konfiguration&gt

#2. Hinzufügen von benutzerdefinierten Protokollstufen im Code

Abgesehen von der Deklaration in der Konfigurationsdatei können Sie Ihre eigenen benutzerdefinierten Protokollstufen auch in Ihrem Code definieren.

final Level VERBOSE = Level.forName("VERBOSE", 550);

Damit wird eine neue Protokollstufe namens VERBOSE erstellt. Diese Protokollstufe liegt zwischen DEBUG (mit einem Wert von 500) und TRACE (mit einem Wert von 600). Wenn der Logger auf die Stufe VERBOSE eingestellt ist, werden alle Protokollmeldungen ab VERBOSE protokolliert, einschließlich DEBUG. TRACE-Meldungen werden jedoch übersprungen.

#3. Verwendung der benutzerdefinierten Protokollierungsstufe im Code

Benutzerdefinierte Protokollebenen müssen zunächst deklariert werden, bevor sie verwendet werden können. Sie können sie entweder in der Konfigurationsdatei oder in Ihrem Code deklarieren. Sobald sie deklariert sind, können Sie sie frei verwenden.

Dieses Codebeispiel zeigt, wie Sie eine benutzerdefinierte Stufe namens NOTICE deklarieren und dann verwenden können.

final Level NOTICE = Level.forName("NOTICE", 550);

final Logger logger = LogManager.getLogger();
logger.log(NOTICE, "a notice level message");

Obwohl dies die erforderliche Meldung mit der neu erstellten Stufe erzeugt, könnte es mühsam werden, die Stufe immer explizit zu übergeben. Zum Glück können Sie Quellcode generieren, so dass Sie Hilfsmethoden für die Protokollierung Ihrer benutzerdefinierten Ebenen erhalten. Damit können Sie Ihre eigene Methode von logger.notice() verwenden, ähnlich wie Sie logger.debug() oder logger.error() verwenden würden.

Log4j2 wird mit einem Dienstprogramm geliefert, mit dem Sie Ihre eigenen erweiterten Logger erstellen können. Der folgende Befehl erstellt eine Java-Datei namens CustomLogger.java. Diese Datei enthält die vorhandenen Log-Methoden sowie die neu erstellten Methoden für die Ebene NOTICE.

java -cp log4j-core-2.20.0.jar org.apache.logging.log4j.core.tools.ExtendedLoggerGenerator \
 com.example.CustomLogger NOTICE=450 > com/example/CustomLogger.java

Sobald die Datei generiert ist, können Sie die Klasse in Ihrem Code verwenden, um neue Logger zu erstellen. Diese Logger enthalten zusätzliche Methoden für Ihre benutzerdefinierte Protokollstufe. So können Sie die Funktionalität Ihrer Logger erweitern.

final Logger logger = CustomLogger.create(ValueFirstSmsSender.class);

//diese neue Methode ähnelt der Verwendung von logger.debug()
logger.notice("eine Nachricht der Benachrichtigungsebene");

Schlussfolgerung

Log4j2 ist ein sehr leistungsfähiges Java-Protokollierungs-Framework, das eine breite Palette von Funktionen, Konfigurationen, Leistungsverbesserungen und mehr bietet. Da Protokolle ein sehr wichtiger Teil des Softwareentwicklungsprozesses sind, verbessert ein robustes Framework wie Log4j2 die Fähigkeiten der Anwendung.

Die Flexibilität und Erweiterbarkeit von Log4j2 ermöglicht die korrekte Erfassung von Ereignissen in Ihrer Anwendung. Dadurch können Sie Protokolle als leistungsstarkes Werkzeug für Debugging und Auditing betrachten. Mit all seinen Funktionen und Verbesserungen hebt sich Log4j2 von der Masse ab und macht sich zur bevorzugten Wahl für eine Vielzahl von Softwareprojekten.

Vielleicht interessieren Sie sich auch für diese Java-IDEs und Online-Compiler.