Logger in Java – Esempio di registrazione Java

Tutorial

Oggi esamineremo Logger in Java. Java Logger fornisce il logging nella programmazione Java.

Logger in Java

Java Logging API è stata introdotta nella versione 1.4 e puoi utilizzare l’API di logging di Java per registrare i messaggi dell’applicazione. In questo tutorial sul logging di Java, impareremo le funzionalità di base di Java Logger. Guarderemo anche l’esempio di Java Logger di diversi livelli di logging, Gestori di Logging, Formattatori, Filtri, Gestore di Log e configurazioni di logging.

Java Logger

java.util.logging.Logger è la classe utilizzata per registrare i messaggi dell’applicazione nell’API di logging di Java. Possiamo creare un Logger Java con un codice molto semplice in una sola riga come segue;

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

Livelli di Logging di Java

Il java.util.logging.Level definisce i diversi livelli di logging di Java. Ci sono sette livelli di logging in Java.

  1. SEVERE (il più alto)
  2. WARNING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Ci sono altri due livelli di logging, OFF che disattiverà tutto il logging e ALL che registrerà tutti i messaggi. Possiamo impostare il livello del logger utilizzando il seguente codice:

logger.setLevel(Level.FINE);

I log verranno generati per tutti i livelli uguali o superiori al livello del logger. Ad esempio, se il livello del logger è impostato su INFO, verranno generati log per i messaggi di logging INFO, WARNING e SEVERE.

Gestori di Logging Java

Possiamo aggiungere più gestori a un logger Java e ogni gestore elaborerà il messaggio di logging di conseguenza. Ci sono due gestori predefiniti forniti dall’API di logging di Java.

  1. ConsoleHandler: Questo gestore scrive tutti i messaggi di logging sulla console
  2. FileHandler: Questo gestore scrive tutti i messaggi di logging su file nel formato XML.

Possiamo anche creare i nostri gestori personalizzati per eseguire compiti specifici. Per creare la nostra classe di gestione personalizzata, dobbiamo estendere la classe java.util.logging.Handler o una delle sue sottoclassi come StreamHandler, SocketHandler, ecc. Ecco un esempio di un gestore di registrazione Java personalizzato:

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) {
        // aggiungere la propria logica per pubblicare
        super.publish(record);
    }


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


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

}

Formattatori di registrazione Java

I formattatori vengono utilizzati per formattare i messaggi di registro. Ci sono due formattatori disponibili nell’API di registrazione Java.

  1. SimpleFormatter: Questo formattatore genera messaggi di testo con informazioni di base. ConsoleHandler utilizza questa classe formattatore per stampare i messaggi di registro sulla console.
  2. XMLFormatter: Questo formattatore genera messaggi XML per il registro, FileHandler utilizza XMLFormatter come formattatore predefinito.

Possiamo creare la nostra classe formattatore personalizzata estendendo la classe java.util.logging.Formatter e allegarla a uno qualsiasi dei gestori. Ecco un esempio di una semplice classe formattatore personalizzata.

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

La classe java.util.logging.LogManager è quella che legge la configurazione del registro, crea e mantiene le istanze del registratore. Possiamo utilizzare questa classe per impostare la nostra configurazione specifica dell’applicazione.

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

Ecco un esempio di file di configurazione API di registrazione Java. Se non specifichiamo alcuna configurazione, viene letta dal file lib/logging.properties nella home di JRE. mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# l'output predefinito del file è nella directory home dell'utente.
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

# Limitare i messaggi stampati sulla console a INFO e superiori.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Ecco un semplice programma Java che mostra l’uso del Logger in Java.

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());
        //aggiunta gestore personalizzato
        logger.addHandler(new MyHandler());
        try {
            //Nome del gestore di file con dimensione massima e limite di numeri di file di registro
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            //impostazione filtro personalizzato per FileHandler
            fileHandler.setFilter(new MyFilter());
            logger.addHandler(fileHandler);
            
            for(int i=0; i<1000; i++){
                //messaggi di registrazione
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Quando eseguirai il programma di esempio sopra del logger Java, noterai che il log CONFIG non viene stampato nel file, questo è dovuto alla classe MyFilter.

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) {
		//non registrare i log CONFIG nel file
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

Inoltre, il formato di output sarà lo stesso definito dalla classe MyFormatter.

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

Se non aggiungiamo la nostra classe Formatter personalizzata a FileHandler, il messaggio di log verrà stampato così.

<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>

I messaggi di log sulla console saranno nel seguente formato:

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

Nell’immagine sottostante viene mostrato il progetto finale di esempio del logger Java. Questo è tutto per il Logger in Java e l’esempio di Logger Java. Puoi scaricare il progetto dal link sottostante.

Scarica il progetto di esempio del registratore Java

Riferimento: API di registrazione Java

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