1.1 Einführung in Protokolle
Das Protokoll ist eine Liste der aufgetretenen Ereignisse. Fast wie ein nautisches Tagebuch. Nun, dementsprechend ist ein Logger ein Objekt, mit dem man protokollieren kann. Beim Programmieren ist es üblich, fast alles zu protokollieren. Und in Java ist alles so und sogar noch ein bisschen mehr.
Tatsache ist, dass Java-Programme sehr oft große Serveranwendungen ohne Benutzeroberfläche, Konsole usw. sind. Sie verarbeiten Anfragen von Tausenden Benutzern gleichzeitig und häufig treten verschiedene Fehler auf. Vor allem, wenn verschiedene Threads beginnen, sich gegenseitig zu stören.
Und tatsächlich besteht die einzige Möglichkeit, selten reproduzierte Fehler und Ausfälle in einer solchen Situation zu finden, darin, alles , was in jedem Thread passiert, in das Protokoll/die Datei zu schreiben.
Am häufigsten werden Informationen über die Parameter der Methode, mit der sie aufgerufen wurde, alle abgefangenen Fehler und viele Zwischeninformationen in das Protokoll geschrieben. Je vollständiger das Protokoll ist, desto einfacher ist es, den Ablauf der Ereignisse wiederherzustellen und die Ursachen eines Ausfalls oder Fehlers nachzuvollziehen.
Doch je größer der Stamm, desto schwieriger ist die Arbeit damit. Manchmal erreichen die Protokolle mehrere Gigabyte pro Tag. Es ist in Ordnung.
1.2 Fehlgeschlagene Protokolle
Als erste Protokolle nutzten die Entwickler die einfache Ausgabe auf die Konsole . Dies ist praktisch beim Debuggen der Anwendung, wenn alle wichtigen Informationen und Variablenwerte in die Konsole geschrieben werden. Ein solches Protokoll ist jedoch während des normalen Betriebs der Anwendung völlig unbrauchbar.
Erstens möchte die Anwendung möglicherweise selbst etwas auf der Konsole ausgeben und der Benutzer möchte die für den Programmierer bestimmten Dienstinformationen überhaupt nicht sehen.
Zweitens ist die Größe des Konsolenpuffers begrenzt, man kann dort nicht viel schreiben.
Und drittens sollten schließlich über einen längeren Zeitraum gesammelte Informationen über Programmfehler an die Programmentwickler gesendet werden. Und am bequemsten ist es, alle diese Informationen auf einmal in eine Datei zu schreiben.
Die Entwickler lösten schnell das erste Problem – sie entwickelten einen weiteren Ausgabestream – System.err. Sie können dort Nachrichten schreiben und diese werden an einen separaten Thread und nicht an die Standardkonsole gesendet.
Und sogar das Problem beim Schreiben in eine Datei wurde gelöst:
// Define the file to which we will write the log
System.setErr(new PrintStream(new File("log.txt")));
// Display messages
System.err.println("Message 1");
System.err.println("Message 2");
// Display an error message
try {
throw new Exception("Error message");
} catch (Exception e) {
e.printStackTrace();
}Aber selbst in dieser Form löste es nicht das ganze Problem, daher wurde beschlossen, eine spezielle Bibliothek zu erstellen, die Protokollmeldungen in eine Datei schreibt. Sie hat dies auf intelligente Weise getan und die Flexibilität ermöglicht, Filter für protokollierte Ereignisse und Daten zu konfigurieren.
Der gesamte Protokollierungsprozess besteht tatsächlich aus drei Teilen:
- Der erste Teil ist das Sammeln von Informationen .
- Der zweite Teil ist die Filterung der gesammelten Informationen.
- Der dritte Teil ist die Aufzeichnung der ausgewählten Informationen.
1.3 Einführung in den log4j-Logger
Der erste beliebte Logger in der Java-Community war der log4j. Das Einbinden in das Projekt ist sehr einfach. Dazu müssen Sie nur ein paar Zeilen zu Ihrer pom.xml hinzufügen
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>2.2.17</version>
</dependency>Die Interaktion Ihres Programms mit einem solchen Logger würde etwa so aussehen:
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}Hier passieren drei Dinge:
Die Erstellung des Objekts wird grün hervorgehoben Logger . Sein Objekt wird in einer statischen Variablen gespeichert, um eine bequeme weitere Arbeit damit zu ermöglichen. Außerdem getLogger()werden der Methode Informationen über die Klasse übergeben, in der die Informationen gesammelt werden.
In der blau hervorgehobenen Zeile protokollieren wir nur während des Debuggens wertvolle Informationen . Hierzu kommt eine spezielle Methode zum Einsatz -debug()
Und schließlich wird die Zeile, in der wir die aufgetretene Ausnahme im Protokoll speichern, rot hervorgehoben . Ausnahmen sind potenzielle Fehler, also die error().