Informationen zur Protokollebene von java.util.logging.Logger

Was ist java.util.logging.Logger?

Java-Standard-API. Protokolliert die Fehlerinformationen entsprechend dem Inhalt.

wie benutzt man

Zunächst die Grundnutzung. Die Hauptauftritte sind die folgenden drei.

Logger - Ein Objekt, das Protokolle ausgibt.
Handler - Ein Objekt, das das Ausgabeziel des Protokolls steuert.
Formatierer - Ein Objekt, das das Format des Protokolls steuert.

Erstellen Sie zunächst eine Logger-Instanz.

Logger logger = Logger.getLogger("Loggername")

Erstellen Sie als Nächstes eine Handler-Instanz und registrieren Sie sie beim Logger. Sie können mehrere Handler registrieren. Erstellen Sie dieses Mal einen Handler mit C: \ sample \ sample.log als Ausgabeziel. Wenn Sie in eine Datei ausgeben möchten, verwenden Sie die Implementierungsklasse FileHandler für die Handler-Schnittstelle.

Handler handler = new FileHandler("C:\\sample\\sample.log");
logger.addHandler(handler);

Erstellen Sie abschließend eine Formatter-Instanz und registrieren Sie sie im Handler. Dieses Mal werden wir SimpleFormatter verwenden, um es in einer Form zu formatieren, die für Menschen leicht zu lesen ist. SimpleFormatter ist eine Implementierungsklasse der Formatter-Schnittstelle.

Formatter formatter =  new SimpleFormatter();
handler.setFormatter(formatter);

Jetzt können Sie loslegen. Übergeben Sie die Nachricht an den Logger und geben Sie das Protokoll aus.

Protokollstufe

Geben Sie die Protokollebene bei der Ausgabe des Protokolls an. Sie können die folgenden Anforderungsstufen festlegen:

Logger-Methode	Entsprechende Anforderungsstufe	Ausgabename
--	Level.ALL	--
Logger.finest()	Level.FINEST	Am detailliertesten
Logger.finer()	Level.FINER	Einzelheiten
Logger.fine()	Level.FINE	gewöhnlich
Logger.config()	Level.CONFIG	Verfassung
Logger.info()	Level.INFO	Information
Logger.warning()	Level.WARNING	Warnung
Logger.severe()	Level.SEVERE	Ernst

Wenn beispielsweise Level.CONFIG festgelegt ist, lautet die Protokollausgabe "Konfiguration", "Information", "Warnung", "Kritisch" und liegt unter dem festgelegten Wert. Level.ALL zeigt, wie der Name schon sagt, alles an.

Bestätigung durch Implementierung

Überprüfen Sie die tatsächliche Protokollausgabe anhand der folgenden Implementierung.

`Log`


public class Log {

	public static Logger getLog(String name) {
		//Logger generieren
		Logger logger = Logger.getLogger(name);

		try {
			//Handler-Generierung (true):Schreiben,false:Überschreiben)
			Handler handler = new FileHandler("/log/sample.log", false);
			//Festlegen des Protokollformats mit SimpleFormat
			handler.setFormatter(new SimpleFormatter());
			//Geben Sie die Protokollebene an/Handler-Einstellungen
		    logger.addHandler(handler);
		    logger.setLevel(Level.ALL);

		    //Standardausgabeeinstellungen
		    ConsoleHandler consoleHandler = new ConsoleHandler();
			consoleHandler.setLevel(Level.CONFIG);
			logger.addHandler(consoleHandler);

		    //Übergeordnete Logger-Einstellungen(true:An übergeordneten Logger senden,false:An übergeordneten Logger sendenしない)
			logger.setUseParentHandlers(false);
			//Protokollausgabe
			logger.finest("FNST");
			logger.finer("FNR");
			logger.fine("FN");
			logger.config("CFG");
			logger.info("INF");
			logger.warning("WNG");
			logger.severe("SVR");

			throw new IOException();

		}  catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
			logger.log(Level.CONFIG, "Ein Fehler ist aufgetreten", e);
			logger.warning("WNG:Ein Fehler ist aufgetreten");
		}
		return logger;
	}
}

Diese Klasse wird eine Klasse sein, die `` `java.util.logging.Logger``` umschließt Überprüfen Sie das Protokollverhalten, indem Sie die Methode getLog () mit dem Klassennamen als Argument aufrufen

Verwenden Sie getLogger (), um einen Logger zu generieren und die Protokollstufe festzulegen

Generieren Sie einen Logger mit der Methode getLogger von `` `java.util.logging.Logger``` Geben Sie die Protokollebene mit der setLevel-Methode an

Einstellung für die Ausgabe als Datei (FileHandler)

Legen Sie den Speicherort, das Format und die Protokollstufe der Protokolldatei fest. Verwenden Sie FileHandler, um das erste Argument festzulegen: Dateipfad, zweites Argument: überschreiben / anhängen true wird überschrieben und false wird hinzugefügt. Dieses Mal möchte ich das Verhalten sehen, wenn es einmal ausgeführt wird. Setzen Sie es also auf true Legen Sie das Protokollformat für den generierten Handler fest Standardmäßig wird das Protokoll im XML-Format ausgegeben, ist jedoch schwer zu erkennen. Stellen Sie es daher so ein, dass es mit SimpleFormatter () auf Japanisch ausgegeben wird. Sie können die Protokollebene im Handler festlegen und den Protokollierer so einstellen, dass nur Nachrichten über einer bestimmten Protokollebene ausgegeben werden. Dieses Mal werden durch Setzen von ALL alle Protokollausgaben in der Datei beschrieben.

Standardausgabe einstellen (ConsoleHandler)

Durch Festlegen von ConsoleHandler kann der Inhalt des Protokolls auch auf der Konsole überprüft werden. Die Einstellungsmethode kann sowohl mit der Methode addHandler () als auch mit FileHandler durchgeführt werden. Stellen Sie die Protokollstufe auch für die Standardausgabe so ein, dass Protokolle von CONFIG oder höher ausgegeben werden.

Übergeordnete Logger-Einstellungen

False ist gesetzt, aber wenn es auf true gesetzt ist, wird die Standardausgabe unterhalb des erforderlichen Pegels zweimal angezeigt oder der Pegel stimmt nicht überein. Zweimal wird angezeigt, dass das erstellte Protokoll an den übergeordneten Protokollierer gesendet wird, sodass das im übergeordneten Protokollierer registrierte Protokoll ausgegeben wird.

Protokolleinstellungen

Jede Protokollebene wird zur Protokollbestätigung ausgegeben.

Überprüfen Sie das Protokoll, wenn ein Fehler auftritt

Ich habe eine IOException ausgelöst und sie mit dem Protokoll verknüpft, als der letzte Fehler aufgetreten ist.

Erstellen Sie eine Maiin-Klasse und rufen Sie sie auf, um ihr Verhalten zu überprüfen.

Ausführungsergebnis

`Sample.log`


9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Am detailliertesten: FNST
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Einzelheiten: FNR
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
gewöhnlich: FN
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Verfassung: CFG
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Information: INF
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Warnung: WNG
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Ernst: SVR
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Verfassung:Ein Fehler ist aufgetreten
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)

9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Warnung: WNG:Ein Fehler ist aufgetreten

Dank SimpleFormatter () konnte ich bestätigen, dass das Protokoll so geändert wurde, dass es im japanischen statt im XML-Format ausgegeben wird. Alle Protokolle werden ausgegeben, da die Protokollstufe des Protokollierers auf ALL gesetzt ist.

`Standardausgabe`


9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Verfassung: CFG
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Information: INF
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Warnung: WNG
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Ernst: SVR
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)
9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Verfassung:Ein Fehler ist aufgetreten
java.io.IOException
	at app.abstractDemo.log.Log.getLog(Log.java:43)
	at app.abstractDemo.MainActivity.main(MainActivity.java:10)

9 21, 2020 2:18:27 Uhr App.abstractDemo.log.Log getLog
Warnung: WNG:Ein Fehler ist aufgetreten

Da die Protokollstufe von consoleHandler in CONFIG festgelegt ist, wurde bestätigt, dass Protokolle ausgegeben werden, die höher als CONFIG sind.

Filter

Ich habe vorgestellt, wie die Protokollebene im Logger festgelegt und so gesteuert wird, dass nur Nachrichten über einer bestimmten Protokollebene ausgegeben werden. Wenn Sie jedoch eine detailliertere Steuerung wünschen, verwenden Sie die Filterklasse.

Filter filter = new Filter() {
    @Override
    public boolean isLoggable(LogRecord record) {
        return record.getMessage().contains("Anzahl der bearbeiteten Fälle=");
    }
};
logger.setFilter(filter);

Wenn Filter wie oben eingestellt ist, werden in der Nachricht nur Protokolle ausgegeben, die "Anzahl der Prozesse =" enthalten. Fügen Sie der Implementierung den folgenden Datensatz hinzu und überprüfen Sie den Prozess

`Log`


	        //Setzen Sie einen Filter auf den Logger
	        Filter filter1 = new Filter() {
	            @Override
	            public boolean isLoggable(LogRecord record) {
	                return record.getMessage().contains("Anzahl der bearbeiteten Fälle=");
	            }
	        };
	        logger.setFilter(filter1);
	        logger.info("Beispielnachricht");                          //Nicht ausgegeben
	        logger.info("Beispielnachricht,Anzahl der bearbeiteten Fälle=1");               //Ausgabe

	        //Setzen Sie einen Filter auf den Handler
	        Filter filter2 = (record) -> record.getMessage().contains("Anzahl der Updates=");
	        handler.setFilter(filter2);
	        logger.info("Beispielnachricht");                          //Nicht ausgegeben
	        logger.info("Beispielnachricht,Anzahl der bearbeiteten Fälle=1");               //Nicht ausgegeben
	        logger.info("Beispielnachricht,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1");    //Ausgabe

	        //Legen Sie die Protokollstufe im Handler fest
	        handler.setLevel(Level.WARNING);
	        logger.info("Beispielnachricht");                          //Nicht ausgegeben
	        logger.info("Beispielnachricht,Anzahl der bearbeiteten Fälle=1");               //Nicht ausgegeben
	        logger.info("Beispielnachricht,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1");    //Nicht ausgegeben
	        logger.warning("Warnmeldung,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1");   //Ausgabe

Es wird davon ausgegangen, dass nur das Protokoll ausgegeben wird, das als vom Filter und der Protokollebene kommentiert geschrieben wurde.

Ausführungsergebnis

`sample.log`


9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Warnung: Warnungメッセージ,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1

Wie erwartet werden drei Protokolle ausgegeben.

`Standardausgabe`


9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Information:Beispielnachricht,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1
9 21, 2020 12:14:03 nachmittags app.abstractDemo.log.Log getLog
Warnung: Warnungメッセージ,Anzahl der bearbeiteten Fälle=1,Anzahl der Updates=1

Da in consoleHandler kein Filter festgelegt ist, wird nur die im Logger festgelegte Filtereinstellung angewendet. Daher werden die in filler1 festgelegte "Anzahl der Prozesse =" und die in consoleHandler festgelegte Protokollebene "CONFIG" angewendet und ausgegeben.

Protokollausgabesteuerung

Der für den Logger festgelegte Filter für die Protokollstufe wird nur von dem direkt aufgerufenen Logger überprüft. Die im Handler festgelegte Filterprüfung auf Protokollebene wird von allen Handlern einschließlich des Handlers des übergeordneten Loggers überprüft. Grob gesagt entspricht die Protokollausgabelogik der folgenden Abbildung.

Der im Logger festgelegte Filter auf Protokollebene wird nur beim ersten Logger überprüft, der den Anruf empfängt, während er aktiviert ist. Alle Handler überprüfen den im Handler festgelegten Protokollstufenfilter.

Da die Logger-Einstellungen nur zum Zeitpunkt des Aufrufs vorgenommen werden, werden sie nicht an den übergeordneten Logger weitergegeben, und die Protokollausgabe entspricht möglicherweise nicht den Erwartungen. Beispiel: Übergeordneter Logger: WARNUNG, untergeordneter Logger: FEIN Handler: ALL

Bei der Einstellung wird das in FINE festgelegte Protokoll ausgegeben, obwohl die Protokollstufe im übergeordneten Logger in WARNING festgelegt ist. Dies liegt daran, dass die Handlereinstellungen vererbt und überprüft werden, sodass der übergeordnete Logger anscheinend nicht festgelegt ist. Die Einstellungen können angewendet werden, indem Sie zu den folgenden Einstellungen wechseln. Übergeordneter Logger / untergeordneter Logger: ALL Handler: WRANING

Eigenschaftendatei lesen

Wenn Sie die Protokolleinstellungen in die Quelle schreiben, ist dies kompliziert und schwer zu lesen.

Die Methode zum Lesen der Einstellungsdatei aus dem Programm lautet wie folgt. Dieses Mal werden logging.properties gelesen, die sich im selben Klassenpfad des Beispielprogramms befinden. Die Konfigurationsdatei muss im Format java.util.Properties gelesen werden.

LogManager.getLogManager().readConfiguration(SettingFileSample.class.getResourceAsStream("logging.properties"));

Die Beispieleinstellungsdatei lautet wie folgt. Eine ausführliche Erklärung finden Sie unter {java.home} \ lib \ logging.properties.

`logging.properties`


#Einstellung der Protokollstufe des Root-Logger-Handlers ConsoleHandler hat einen Standardfehler(System.err)Geben Sie das Protokoll an aus.
handlers=java.util.logging.ConsoleHandler
.level=INFO

#Logger, der im Beispielprogramm verwendet wird"sample.SettingFileSample"Einstellungen von
sample.SettingFileSample.level=FINE
sample.SettingFileSample.handlers=java.util.logging.FileHandler

#ConsoleHandler-Einstellungen
java.util.logging.ConsoleHandler.level=INFO
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter

#FileHandler-Einstellungen
java.util.logging.FileHandler.pattern=C:/sample/sample.log
java.util.logging.FileHandler.limit=1000
java.util.logging.FileHandler.count=1
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter

Das Beispielprogramm, das die obige Einstellungsdatei verwendet, wird unten beschrieben.

`SettingFileSample`


public class SettingFileSample {

    public static void main(String[] arg) throws SecurityException, IOException {
        LogManager.getLogManager().readConfiguration(SettingFileSample.class.getResourceAsStream("logging.properties"));

        Logger logger = Logger.getLogger("sample.SettingFileSample");
        logger.finer("FINER Nachricht");
        logger.fine("FEINE Nachricht");
        logger.info("INFO Nachricht");
    }
}

Es ist ordentlich, weil es keine Logger- oder Handler-Einstellungen gibt.

Referenzartikel

Verwendung von java.util.logging