Logger in Java – Java Logging Beispiel

Tutorials

Heute werden wir uns den Logger in Java ansehen. Java Logger bietet Logging in der Java-Programmierung an.

Logger in Java

Java Logging API wurde in Version 1.4 eingeführt und Sie können die Java-Logging-API verwenden, um Anwendungsnachrichten zu protokollieren. In diesem Java-Logging-Tutorial werden wir grundlegende Funktionen des Java-Loggers erlernen. Wir werden uns auch ein Java-Logger-Beispiel für verschiedene Protokollierungsstufen, Protokollierungs-Handler, Formatter, Filter, Log-Manager und Protokollierungskonfigurationen ansehen.

Java Logger

java.util.logging.Logger ist die Klasse, die verwendet wird, um Anwendungsnachrichten in der Java-Logging-API zu protokollieren. Wir können einen Java-Logger mit sehr einfacher Einzeilencode erstellen, wie folgt:

Logger logger = Logger.getLogger(MyClass.class.getName());

Java-Protokollierungsstufen

java.util.logging.Level definiert die verschiedenen Ebenen des Java-Loggings. Es gibt sieben Ebenen des Loggings in Java.

  1. SEVERE (höchste)
  2. WARNING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Es gibt zwei weitere Log-Ebenen, OFF, die alle Protokollierungen deaktivieren, und ALL, die alle Nachrichten protokollieren. Wir können die Logger-Ebene mit folgendem Code festlegen:

logger.setLevel(Level.FINE);

Die Protokolle werden für alle Ebenen generiert, die gleich oder höher als die Logger-Ebene sind. Zum Beispiel werden bei Einstellung der Logger-Ebene auf INFO Protokolle für INFO-, WARNING- und SEVERE-Protokollnachrichten generiert.

Java-Protokoll-Handler

Wir können mehrere Handler zu einem Java-Logger hinzufügen, und jedes Mal, wenn wir eine Nachricht protokollieren, wird jeder Handler sie entsprechend verarbeiten. Es gibt zwei Standardhandler, die von der Java-Logging-API bereitgestellt werden.

  1. ConsoleHandler: Dieser Handler schreibt alle Protokollnachrichten in die Konsole
  2. FileHandler: Dieser Handler schreibt alle Protokollnachrichten in eine Datei im XML-Format.

Wir können auch unsere eigenen benutzerdefinierten Handler erstellen, um spezifische Aufgaben auszuführen. Um unsere eigene Handler-Klasse zu erstellen, müssen wir die Klasse java.util.logging.Handler oder eine ihrer Unterklassen wie StreamHandler, SocketHandler usw. erweitern. Hier ist ein Beispiel für einen benutzerdefinierten Java-Protokollhandler:

package com.journaldev.log;

import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;

public class MyHandler extends StreamHandler {

    @Override
    public void publish(LogRecord record) {
        //eigene Logik hinzufügen
        super.publish(record);
    }


    @Override
    public void flush() {
        super.flush();
    }


    @Override
    public void close() throws SecurityException {
        super.close();
    }

}

Java-Protokollformatierer

Formatierer werden verwendet, um die Protokollnachrichten zu formatieren. Es gibt zwei verfügbare Formatierer in der Java-Protokollierungs-API.

  1. SimpleFormatter: Dieser Formatierer generiert Textnachrichten mit grundlegenden Informationen. ConsoleHandler verwendet diese Formatiererklasse, um Protokollnachrichten auf der Konsole auszugeben.
  2. XMLFormatter: Dieser Formatierer generiert XML-Nachrichten für das Protokoll. FileHandler verwendet XMLFormatter als Standardformatierer.

Wir können unsere eigene benutzerdefinierte Formatter-Klasse erstellen, indem wir die Klasse java.util.logging.Formatter erweitern und sie an einen der Handler anhängen. Hier ist ein Beispiel für eine einfache benutzerdefinierte Formatter-Klasse.

package com.journaldev.log;

import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;

public class MyFormatter extends Formatter {

    @Override
    public String format(LogRecord record) {
        return record.getThreadID()+"::"+record.getSourceClassName()+"::"
                +record.getSourceMethodName()+"::"
                +new Date(record.getMillis())+"::"
                +record.getMessage()+"\n";
    }

}

Logger in Java – Java-Log-Manager

Die Klasse java.util.logging.LogManager liest die Logging-Konfiguration, erstellt und verwaltet die Logger-Instanzen. Wir können diese Klasse verwenden, um unsere eigene anwendungsspezifische Konfiguration festzulegen.

LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));

Hier ist ein Beispiel für eine Konfigurationsdatei der Java Logging API. Wenn wir keine Konfiguration angeben, wird sie aus der JRE-Home-Datei lib/logging.properties gelesen. mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# Die Standardausgabedatei befindet sich im Home-Verzeichnis des Benutzers.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Begrenzen der Meldungen, die auf der Konsole auf INFO und höher gedruckt werden.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Hier ist ein einfaches Java-Programm, das die Verwendung des Loggers in Java zeigt.

package com.journaldev.log;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

public class LoggingExample {

    static Logger logger = Logger.getLogger(LoggingExample.class.getName());
    
    public static void main(String[] args) {
        try {
            LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));
        } catch (SecurityException | IOException e1) {
            e1.printStackTrace();
        }
        logger.setLevel(Level.FINE);
        logger.addHandler(new ConsoleHandler());
        // Hinzufügen eines benutzerdefinierten Handlers
        logger.addHandler(new MyHandler());
        try {
            // DateiHandler-Dateiname mit maximaler Größe und Anzahl von Protokolldateien
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            // Festlegen eines benutzerdefinierten Filters für den DateiHandler
            fileHandler.setFilter(new MyFilter());
            logger.addHandler(fileHandler);
            
            for(int i=0; i<1000; i++){
                // Protokollierung von Nachrichten
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Wenn Sie das obige Java-Logger-Beispielprogramm ausführen, werden Sie feststellen, dass das CONFIG-Protokoll nicht in der Datei gedruckt wird, das liegt an der MyFilter-Klasse.

package com.journaldev.log;

import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;

public class MyFilter implements Filter {

	@Override
	public boolean isLoggable(LogRecord log) {
		// CONFIG-Protokolle nicht in Datei protokollieren
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

Außerdem wird das Ausgabeformat genauso sein wie von der MyFormatter-Klasse definiert.

1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg977
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg978
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg979
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg980

Wenn wir unserer FileHandler-Klasse keine eigene Formatter-Klasse hinzufügen, wird die Protokollnachricht wie folgt gedruckt.

<record>
  <date>2012-12-14T17:03:13</date>
  <millis>1355533393319</millis>
  <sequence>996</sequence>
  <logger>com.journaldev.log.LoggingExample</logger>
  <level>INFO</level>
  <class>com.journaldev.log.LoggingExample</class>
  <method>main</method>
  <thread>1</thread>
  <message>Msg996</message>
</record>

Konsolenprotokollnachrichten haben das folgende Format:

Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg997
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998

Das folgende Bild zeigt das finale Java-Logger-Beispielprojekt. Das ist alles für den Logger in Java und das Java-Logger-Beispiel. Sie können das Projekt über den untenstehenden Link herunterladen.

Laden Sie das Java-Logger-Beispielprojekt herunter

Referenz: Java-Logging-API

Source:
https://www.digitalocean.com/community/tutorials/logger-in-java-logging-example