Perché i log sono necessari in Java

1.1 Introduzione ai log

Il registro è un elenco di eventi che si sono verificati. Quasi come un diario o un diario nautico. Bene, di conseguenza, un logger è un oggetto con cui puoi accedere. Nella programmazione, è consuetudine registrare quasi tutto. E in Java tutto è così e anche un po 'di più.

Il fatto è che i programmi Java sono molto spesso applicazioni server di grandi dimensioni senza interfaccia utente, console e così via. Elaborano le richieste di migliaia di utenti contemporaneamente e spesso si verificano vari errori. Soprattutto quando diversi thread iniziano a interferire tra loro.

E, infatti, l'unico modo per trovare errori e guasti raramente riprodotti in una situazione del genere è scrivere nel registro / file tutto ciò che accade in ogni thread.

Molto spesso, nel registro vengono scritte informazioni sui parametri del metodo con cui è stato chiamato, tutti gli errori intercettati e molte informazioni intermedie. Più il registro è completo, più è facile ripristinare la sequenza degli eventi e risalire alle cause di un guasto o di un errore.

Ma più grande è il registro, più difficile è lavorarci. A volte i log raggiungono diversi gigabyte al giorno. Questo va bene.

1.2 Registri non riusciti

Come primi log, gli sviluppatori hanno utilizzato semplicemente l'output sulla console . È conveniente farlo durante il debug dell'applicazione, quando tutte le informazioni importanti e i valori delle variabili vengono scritti nella console. Ma un tale registro è completamente inapplicabile durante il normale funzionamento dell'applicazione.

In primo luogo, l'applicazione potrebbe voler inviare qualcosa alla console stessa e l'utente non desidera affatto vedere le informazioni di servizio destinate al programmatore.

In secondo luogo, la dimensione del buffer della console è limitata, non puoi scrivere molto lì.

Infine, in terzo luogo, le informazioni sugli errori del programma raccolte per un lungo periodo di tempo dovrebbero essere inviate agli sviluppatori del programma. Ed è più conveniente scrivere tutte queste informazioni contemporaneamente in un file.

Gli sviluppatori hanno risolto rapidamente il primo problema - hanno escogitato un altro flusso di output - System.err. Puoi scrivere messaggi su di esso e verranno inviati a un thread separato e non alla console standard.

E anche il problema con la scrittura su un file è stato risolto:

// 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();
}

Ma anche in questa forma non ha risolto l'intero problema, quindi è stato deciso di creare una libreria speciale che scrivesse i messaggi di registro in un file. Lo ha fatto in modo intelligente e ha consentito la flessibilità di configurare i filtri per eventi e dati registrati.

L'intero processo di registrazione, infatti, si compone di tre parti:

• La prima parte è la raccolta di informazioni .
• La seconda parte è il filtraggio delle informazioni raccolte.
• La terza parte è la registrazione delle informazioni selezionate.

1.3 Introduzione al logger log4j

Il primo logger popolare nella comunità Java è stato il log4j. Includerlo nel progetto è molto semplice, per questo devi aggiungere solo un paio di righe al tuo pom.xml

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>2.2.17</version>
</dependency>

L'interazione del tuo programma con un tale logger sarebbe simile a questa:

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

Qui succedono tre cose:

La creazione dell'oggetto è evidenziata in verde Logger . Il suo oggetto è memorizzato in una variabile statica per un comodo ulteriore lavoro con esso. E anche getLogger()le informazioni sulla classe in cui vengono raccolte le informazioni vengono passate al metodo.

La linea evidenziata in blu è dove registriamo le informazioni di valore solo durante il debug . Per questo, viene utilizzato un metodo speciale:debug()

Infine, la riga in cui salviamo l'eccezione che si è verificata nel registro è evidenziata in rosso . Le eccezioni sono potenziali errori, quindi il file error().