Lernen Sie die Grundlagen der Java-Protokollierung

Java hat eine Protokollierungs-API-Bibliothek als Teil seines Frameworks von JDK 1.4 integriert. Heute ist dies eine eingebaute Unterstützung von Java. Diese Bibliothek ist jedoch anpassbar und erweiterbar in dem Sinne, dass wir eine oder mehrere alternative Protokollierungslösungen verwenden können, die von Bibliotheken von Drittanbietern bereitgestellt werden. Obwohl diese Lösungen von Drittanbietern einen anderen Ansatz zum Erstellen von Protokolldaten verfolgen, haben sie letztendlich das gleiche Ziel, Meldungen aus der Anwendungslaufzeit zu protokollieren. Dieser Artikel untersucht die Grundlagen der Protokollierung und zeigt, wie sie in einem Java-Programm verwendet werden kann.

Java-Protokollierung

Ein Protokoll bedeutet normalerweise die Aufrechterhaltung einer Art von Aufzeichnungen. Aus Sicht der Programmierung ist es ein Vorgang, bei dem während der Programmausführung Meldungen in eine Protokolldatei geschrieben werden. Auf persistente Nachrichtenprotokolle wird normalerweise vom Programmierer verwiesen, um bestimmte statistische Laufzeitinformationen zu sammeln, die bei der Analyse unvorhergesehene Situationen aufdecken können. Tatsächlich kann es zahlreiche verschiedene Gründe geben, warum die Protokollierung verwendet wird, und dies ist nur einer davon. Gemäß der Java-API-Dokumentation gibt es vier primäre Verwendungszwecke für die Protokollierung:

• Zur Problemdiagnose durch Endbenutzer und Systemadministratoren.
• Für Außendiensttechniker ist es bequem, das Problem anhand der protokollierten Meldungen zu diagnostizieren und schnell zu beheben.
• Die Entwicklungsorganisation kann die interne Ausführung eines bestimmten Subsystems verfolgen und analysieren.
• Entwickler können die in der Entwicklung befindliche Anwendung debuggen, indem sie anhand von protokollierten Meldungen einen schnellen Einblick in das zugrunde liegende Problem erhalten.

Die Java-API-Protokollierung ist in dem Sinne kostengünstig konzipiert, dass sie sogar in einer Produktionsanwendung als Überbleibsel verbleiben kann. Dies erzeugt nicht viel Overhead für die Effizienz der Programmausführung. Die API stellt den Mechanismus bereit, um die Produktion von Protokollnachrichten dynamisch zu ändern, sodass die Auswirkungen der Protokollierung während Vorgängen minimiert werden können, die maximale Effizienz erfordern. Die API besteht aus einer Reihe von Klassen und Schnittstellen, die durch Erweiterungen angepasst werden können. Die gesamte Protokollierungs-API ist unter java.util.logging gepackt . Die Klassen und Schnittstellen in diesem Paket stellen die zentralen Protokollierungsfunktionen in Java bereit.

Protokollierungsebenen

Die Dringlichkeit der Anmeldung bei einem Java-Programm kann in mehrere Stufen eingeteilt werden. Durch Auf- und Abstufen können wir die Kosten für die Anmeldung in einer Produktionsanwendung erhöhen oder verringern. Auf diese Weise kontrollieren wir die Effizienz der Ausführung einer Anwendung, wenn es notwendig ist, eines oder mehrere ihrer Ereignisse zu protokollieren. Dies wird durch eine Klasse namens Level erreicht , die die Bedeutung der Protokollierung definiert. Die Protokollebene wird geordnet und durch statisch angegeben ganzzahlige Konstanten, wie zum Beispiel:

• Stufe.ALLE: Alle Meldungen werden unabhängig von ihrer Wichtigkeit protokolliert
• Level.AUS: Die Protokollierung ist deaktiviert
• Stufe.SEVERE: Zeigt einen schwerwiegenden Fehler an; müssen angemeldet sein
• Level.WARNUNG: Kennzeichnet Warnmeldungen
• Level.INFO: Informationsnachricht zur Laufzeit
• Ebene.KONFIG: Statische Konfigurationsmeldungen
• Stufe.FEIN: Nachrichten verfolgen
• Level.FINER: Detaillierte Ablaufverfolgungsmeldungen
• Level.FINEST: Hochdetaillierte Ablaufverfolgungsmeldungen

Protokollierungskomponenten

Wir brauchen einen Logger Instanz, um irgendeine Art von Protokollierung in Java durchzuführen. Diese Instanz ist für die Protokollierung von Daten in einem LogRecord verantwortlich . Der LogRecord Instanzen werden verwendet, um Protokollierungsanforderungen zwischen Protokollierungsframeworks und einzelnen Protokollhandlern zu übergeben. Java SE bietet fünf integrierte Handler vom Typ:StreamHandler , ConsoleHandler , FileHandler , SocketHandler und MemoryHandler . Man kann jedoch einen neuen Handler erstellen oder einen davon als Anpassung erweitern. Die Handler bestimmen, was mit dem Protokolldatensatz zu tun ist; Beispielsweise kann es in einem lokalen Repository gespeichert oder über ein Netzwerk an einen Server weitergegeben werden. Java SE enthält außerdem zwei Standardformatierer:SimpleFormatter und XMLFormatter . Diese Formatierer werden verwendet, um einen LogRecord zu formatieren in menschenlesbares Format bzw. Standard-XML-Format.

Es gibt einen LogManager Klasse, die globale Logging-Informationen verfolgt, wie z. B. einen hierarchischen Namensraum von benannten Loggern und eine Reihe von Protokollsteuereigenschaften aus der Konfigurationsdatei. Es ist von zentraler Bedeutung für die Protokollierung in Java und steuert ziemlich genau, was protokolliert wird, wo es protokolliert wird, einschließlich anderer Initialisierungsdetails und so weiter.

Ein einfaches Protokollierungsbeispiel

Erstellen eines Loggers Objekt ist sehr einfach. Hier ist ein sehr einfacher Code, um das zu veranschaulichen.

import java.util.logging.Logger;
public class App {
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) {
      logger.info("This is a log message  !!!");
      logger.info("The name of the logger is " +
         logger.getName() + " nwhich is same as class name: "
            + App.class.getName());
   }
}

Logger Objekte werden normalerweise mit dem String benannt Wert eines hierarchischen, durch Punkte getrennten Namensraums. Im vorangegangenen Fall ist dies derselbe wie der Klassenname. Der Name kann jedoch ein beliebiger String-Wert sein, aber normalerweise basieren Namen auf dem Paketnamen oder dem Klassennamen der protokollierten Komponente. Es ist auch möglich, einen „anonymen“ Logger zu erstellen, der nicht im Logger gespeichert wird Namensraum.

Protokollierung in einer externen Datei mit XML-Formatierung

Im folgenden Code werden die Protokollmeldungen mithilfe von FileHandler in eine Datei umgeleitet .

Der FileHandler kann entweder in eine bestimmte Datei oder in einen rotierenden Satz von Dateien schreiben. Der rotierende Satz von Dateien bedeutet, dass ältere Dateien benannt werden, indem 0,1,2 usw. zum Basisdateinamen hinzugefügt werden. Der XMLFormatter ist die von FileHandler verwendete Standardformatierung .

import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
   private static FileHandler fileHandler;
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) throws
         IOException {
      fileHandler = new
         FileHandler(App.class.getName() + ".log");
      logger.setLevel(Level.ALL);
      logger.addHandler(fileHandler);
      logger.info("Log message redirected to a file");
      logger.info("The name of the logger is " +
         logger.getName() + 
            " nwhich is same as class name: "
            + App.class.getName());
   }
}

Protokollieren in einer externen Datei mit benutzerdefinierter Formatierung

Wir werden den folgenden Code ein wenig optimieren, um die Formatierung der Nachricht anzupassen. Dies ändert, wie die Nachrichten in die externe Datei geschrieben werden.

import java.io.IOException;
import java.util.logging.*;
public class App {
   private static FileHandler fileHandler;
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) throws
         IOException {
      fileHandler = new
         FileHandler(App.class.getName() + ".log");
      logger.setLevel(Level.ALL);
      fileHandler.setFormatter(newCustomFormatter());
      logger.addHandler(fileHandler);
      logger.fine("Log message redirected to a file");
      logger.finer("The name of the logger is " +
         logger.getName());
      loggerfinest("This is same as class name: " +
         App.class.getName());
   }
   private static class CustomFormatter extends Formatter {
      private static final String format =
          "[%1$tF %1$tT] [%2$-4s] %3$s %n";
      public String format(LogRecord record) {
         returnString.format(format,
            record.getMillis(),
            record.getLevel().getLocalizedName(),
            record.getMessage());
      }
   }
}

Das ist alles. Experimentieren Sie mit Java-Logging und probieren Sie viele andere Möglichkeiten aus. Konsultieren Sie bei Bedarf die Java-API-Dokumente.

Andere Protokollierungs-Frameworks in Java

Manchmal ist es praktisch, ein Protokollierungs-Framework eines Drittanbieters zu verwenden, und es stehen einige beliebte zur Auswahl. Beispielsweise verwendet die von SLF4J bereitgestellte Protokollierungs-API ein einfaches Fassadenmuster, eine Abstraktionsschicht, die es ermöglicht, die Anwendung von ihrem Protokollierungsframework zu entkoppeln. Log4j ähnelt syntaktisch der integrierten Java-Protokollierung. Es hat eine Standardkonfiguration, um alle Protokollmeldungen an die Konsole auszugeben. Logback ist ein Nachfolger von Log4j und eine Erweiterung seines Vorgängers. tinyLog ist ein einfaches Protokollierungs-Framework, das sowohl mit Java als auch mit Android verwendet werden kann.

Schlussfolgerung

Der Protokollierungsprozess ist so konzipiert, dass er einfach und effizient das liefert, was er tun soll. Mit Protokollierungs-APIs in Java ist ein schneller Einstieg möglich. Das Design ist erweiterbar und kann an die Endanforderungen des Entwicklers angepasst werden. Dieser Artikel gibt einen Einblick in die Grundlagen der Java-Protokollierung. Viele komplizierte Details wurden der Einfachheit halber weggelassen. Lesen Sie die Java-API-Dokumentation und andere geeignete Dokumente für weitere Einzelheiten dazu.

Referenzen

• Java-Logging-Übersicht
• Java-API-Dokumentation