CIAO! Quando scrivo le lezioni, sottolineo in particolare se c'è un argomento specifico che sarà assolutamente essenziale nel lavoro reale. Quindi, ASCOLTA! L'argomento che tratteremo oggi tornerà sicuramente utile in tutti i tuoi progetti sin dal primo giorno di lavoro. Parleremo di Java Logging. Questo argomento non è affatto complicato (direi anche facile). Ma avrai abbastanza cose ovvie su cui stressarti al tuo primo lavoro, quindi è meglio capirlo a fondo adesso :) Bene, cominciamo.
Che cos'è l'accesso a Java?
La registrazione è l'atto di registrazione dei dati sul funzionamento di un programma. Il luogo in cui registriamo questi dati è chiamato "registro". Sorgono subito due domande: quali dati vengono scritti e dove? Partiamo dal "dove". Puoi scrivere dati sul lavoro di un programma in molti posti diversi. Ad esempio, durante i tuoi studi, spesso System.out.println()per inviare i dati alla console. Questa è davvero la registrazione, anche se nella sua forma più semplice. Ovviamente, questo non è molto conveniente per gli utenti o per un team di supporto del prodotto: ovviamente, non vorranno installare un IDE e monitorare la console :) Esiste un formato più consueto per la registrazione delle informazioni: i file di testo. Gli esseri umani sono molto più a loro agio nel leggere i dati in questo formato, e certamente è molto più comodo per archiviare i dati! Ora la seconda domanda: quali dati del programma devono essere registrati? Dipende interamente da te! Il sistema di registrazione di Java è molto flessibile. Puoi configurarlo per registrare tutto ciò che fa il tuo programma. Da un lato, questo è buono. Ma d'altra parte, immagina quanto sarebbero grandi i log di Facebook o Twitter se ci scrivessero tutto. Queste grandi aziende probabilmente hanno la capacità di archiviare così tanti dati. Ma immagina quanto sarebbe difficile trovare informazioni su un errore critico in 500 gigabyte di registri di testo? Sarebbe peggio che cercare un ago in un pagliaio. Di conseguenza, Java può essere configurato per registrare solo i dati di errore. O anche solo errori critici! Detto questo, non è del tutto corretto parlare del sistema di registrazione nativo di Java. Il fatto è che i programmatori avevano bisogno di accedere prima che questa funzionalità fosse aggiunta al linguaggio. Quando Java ha introdotto la propria libreria di registrazione, tutti utilizzavano già la libreria log4j. La cronologia dell'accesso a Java è in realtà molto lunga e istruttiva. In breve, Java ha la sua libreria di registrazione, ma quasi nessuno la usa :) Più tardi, quando sono apparse diverse librerie di registrazione e hanno iniziato ad essere utilizzate dai programmatori, sono sorti problemi di compatibilità. Per impedire alle persone di reinventare la ruota in una dozzina di librerie diverse con interfacce diverse, è stato creato il framework astratto SLF4J ("Service Logging Facade For Java"). Si chiama astratto, perché anche se usi e chiami i metodi delle classi SLF4J, sotto il cofano usano effettivamente tutti i framework di registrazione precedenti: log4j, lo standard java.util.logging e altri. Se a un certo punto hai bisogno di alcune funzionalità specifiche di Log4j che mancano in altre librerie, ma non vuoi collegare direttamente il tuo progetto a questa libreria, usa semplicemente SLF4J. E poi lascia che chiami i metodi Log4j. Se cambi idea e decidi che non hai più bisogno delle funzionalità di Log4j, devi solo riconfigurare il "qui , e la libreria Log4j qui . Successivamente, decomprimere l'archivio e utilizzare IntelliJ IDEA per aggiungere i file JAR al classpath. Voci di menu: File -> Struttura del progetto -> Librerie Seleziona i file JAR necessari e aggiungili al progetto (gli archivi che abbiamo scaricato contengono molti file JAR — guarda le immagini per vedere quelli che ti servono) Nota che queste istruzioni per quegli studenti che non sanno usare Maven. Se sai come usare Maven, di solito è meglio (molto più facile) provare a iniziare da lì. Se usi Maven , aggiungi questa dipendenza:
Grande! Abbiamo capito le impostazioni :) Vediamo come funziona SLF4J. Come ci assicuriamo che il lavoro del programma sia registrato da qualche parte? Per fare questo, abbiamo bisogno di due cose: logger e appender. Iniziamo con il primo. Un logger è un oggetto che fornisce il controllo completo della registrazione. Creare un logger è molto semplice: lo facciamo usando i metodi statici LoggerFactory.getLogger() . Il parametro del metodo è la classe la cui operazione verrà registrata. Eseguiamo il nostro codice:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyTestClass {
public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);
public static void main(String[] args) {
LOGGER.info("Test log entry!!!");
LOGGER.error("An error occurred!");
}
}
Uscita console:
ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmatically provided configurations. Set system property 'log4j2.debug' to show Log4j 2 internal initialization logging. See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2 15:49:08.907 [main] ERROR MyTestClass - An error occurred!
Cosa vediamo qui? Innanzitutto, vediamo un messaggio di errore. Questo è il risultato del fatto che ora ci mancano le impostazioni necessarie. Di conseguenza, il nostro logger è attualmente in grado di inviare solo messaggi di errore (ERROR) e solo alla console. Il metodo logger.info() non ha funzionato. Ma logger.error() lo ha fatto! Sulla console, vediamo la data corrente, il metodo in cui si è verificato l'errore ( main), la parola "ERRORE" e il nostro messaggio! ERROR è il livello di registrazione. In generale, se una voce di registro è contrassegnata dalla parola "ERROR", si è verificato un errore in questo punto del programma. Se la voce è contrassegnata dalla parola "INFO", il messaggio rappresenta semplicemente informazioni correnti sul normale funzionamento del programma. La libreria SLF4J ha molti diversi livelli di registrazione che ti consentono di configurare la registrazione in modo flessibile. È tutto molto facile da gestire: tutta la logica necessaria è già nella classe Java Logger . Devi solo chiamare i metodi pertinenti. Se vuoi registrare un messaggio di routine, chiama il metodo logger.info(). Per un messaggio di errore, usa logger.error() . Per un avviso, usa logger.warn()
Ora parliamo di appender
Un appender è il luogo in cui vanno i tuoi dati. In un certo senso, l'opposto di una fonte di dati, cioè "punto B". Per impostazione predefinita, i dati vengono inviati alla console. Si noti che nell'esempio precedente non è stato necessario configurare nulla: il testo è apparso nella console e il logger della libreria Log4j può inviare alla console solo messaggi di livello ERROR. Ovviamente, è più conveniente per le persone leggere e scrivere i log in un file di testo. Per modificare il comportamento predefinito del logger, dobbiamo configurare il nostro file appender. Per iniziare, devi creare un file log4j.xml direttamente nella cartella src. Conosci già il formato XML: di recente abbiamo tenuto una lezione a riguardo :) Ecco i contenuti del file:
Niente di particolarmente speciale o difficile qui :) Ma ancora, esaminiamo il contenuto.
<Configuration status="INFO">
Questo è il cosiddetto StatusLogger. Non è correlato al nostro logger e viene utilizzato nei processi interni di Log4j. Se imposti status="TRACE" invece di status="INFO", tutte le informazioni sul lavoro interno di Log4j verranno visualizzate sulla console (StatusLogger visualizza i dati sulla console, anche se il nostro appender è un file). Non ne abbiamo bisogno ora, quindi lasciamolo così com'è.
Qui creiamo il nostro appender. Il tag <File> indica che sarà un appender di file. name="MyFileAppender" imposta il nome dell'appender. fileName="C:\Users\Username\Desktop\testlog.txt" indica il percorso del file di log dove verranno scritti tutti i dati. append="true" indica se i dati devono essere scritti alla fine del file. Nel nostro caso, questo è esattamente ciò che faremo. Se si imposta il valore su false, il vecchio contenuto del file di registro verrà eliminato ogni volta che si avvia il programma. <PatternLayout pattern="%d{yyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>indica le impostazioni di formattazione. Qui possiamo usare le espressioni regolari per personalizzare la formattazione del testo nel nostro registro.
Qui indichiamo il livello radice. Abbiamo impostato il livello "INFO", il che significa che tutti i messaggi i cui livelli sono superiori a INFO (secondo la tabella che abbiamo visto sopra) non verranno registrati. Il nostro programma avrà 3 messaggi: uno INFO, uno WARN e uno ERROR. Con la configurazione corrente, verranno registrati tutti e 3 i messaggi. Se modifichi il livello root in ERROR, solo l'ultimo messaggio dalla chiamata al metodo LOGGER.error() finirà nel log. Inoltre, qui va anche un riferimento all'appender. Per creare un tale riferimento, è necessario creare un tag <ApprenderRef> all'interno del tag <Root> e aggiungervi l' attributo ref='your appender's name' . Nel caso te lo fossi dimenticato, qui è dove impostiamo il nome dell'appender: <. Ed ecco il nostro codice!
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyTestClass {
public static final Logger LOGGER = LoggerFactory.getLogger(MyTestClass.class);
public static void main(String[] args) {
LOGGER.info("The program is starting!!!");
try {
LOGGER.warn("Attention! The program is trying to divide a number by another.
System.out.println(12/0);
} catch (ArithmeticException x) {
LOGGER.error("Error! Division by zero!");
}
}
}
Certo, è un po' strano (catturare una RuntimeException è un'idea discutibile), ma è perfetto per i nostri scopi :) Eseguiamo il nostro metodo main() 4 volte di seguito e guardiamo il nostro file testlog.txt. Non è necessario crearlo in anticipo: la libreria lo farà automaticamente. Tutto ha funzionato! :) Ora hai un logger configurato. Puoi giocare con alcuni dei tuoi vecchi programmi, aggiungendo chiamate di logger a ciascun metodo. Quindi guarda il registro risultante :) Considera in profondità l'argomento della registrazione. Sarebbe difficile leggerlo tutto d'un fiato. Detto questo, contiene molte informazioni utili aggiuntive. Ad esempio, imparerai come configurare il logger in modo che crei un nuovo file di testo se il nostro file testlog.txt raggiunge una certa dimensione :) E questo conclude la nostra lezione! Oggi hai acquisito familiarità con un argomento molto importante e questa conoscenza ti sarà sicuramente utile nel tuo lavoro futuro. Fino alla prossima volta! :)
studenti che non sanno usare Maven. Se sai come usare Maven, di solito è meglio (molto più facile) provare a iniziare da lì. Se usi Maven , aggiungi questa dipendenza:
GO TO FULL VERSION