Java ha incorporato una libreria API di registrazione come parte del suo framework da JDK 1.4. Oggi, questo è un supporto integrato di Java. Tuttavia, questa libreria è personalizzabile ed estensibile nel senso che possiamo utilizzare una o più soluzioni di registrazione alternative fornite da librerie di terze parti. Sebbene queste soluzioni di terze parti abbiano un approccio diverso per creare dati di registro, condividono in definitiva lo stesso obiettivo di registrare i messaggi dal runtime dell'applicazione. Questo articolo esplora le basi della registrazione e mostra come può essere utilizzata in un programma Java.
Registrazione Java
Un registro di solito significa il mantenimento di una sorta di record. Dal punto di vista della programmazione, è un processo di scrittura di messaggi in un file di registro durante l'esecuzione del programma. I registri dei messaggi persistenti vengono indirizzati, in genere dal programmatore, a raccogliere determinate informazioni statistiche di runtime che, una volta analizzate, possono rivelare situazioni impreviste. In effetti, possono esserci numerosi motivi distinti per cui viene utilizzata la registrazione e questo è solo uno di questi. Secondo la documentazione dell'API Java, ci sono quattro usi principali della registrazione:
- Per la diagnosi dei problemi da parte di utenti finali e amministratori di sistema.
- È conveniente per i tecnici dell'assistenza sul campo diagnosticare il problema dai messaggi registrati e risolverlo rapidamente.
- L'organizzazione di sviluppo può tracciare l'esecuzione interna di un particolare sottosistema e analizzarlo.
- Gli sviluppatori possono eseguire il debug dell'applicazione in fase di sviluppo ottenendo una rapida panoramica del problema sottostante dai messaggi registrati.
La registrazione dell'API Java è progettata in modo economico, nel senso che può essere lasciata come residuo anche in un'applicazione di produzione. Ciò non crea molto sovraccarico per l'efficienza dell'esecuzione del programma. L'API fornisce il meccanismo per modificare dinamicamente la produzione dei messaggi di registro in modo da ridurre al minimo l'impatto della registrazione durante le operazioni che richiedono la massima efficienza. L'API è composta da una serie di classi e interfacce che possono essere personalizzate estendendole. L'intera API di registrazione è contenuta in java.util.logging . Le classi e le interfacce in questo pacchetto forniscono le funzionalità di registrazione di base in Java.
Livelli di registrazione
L'urgenza di accedere a un programma Java può essere classificata in diversi livelli. Salendo e scendendo di livello, possiamo aumentare o diminuire il costo della registrazione in un'applicazione di produzione. Questo è il modo in cui controlliamo l'efficienza dell'esecuzione di un'applicazione quando è necessario registrare uno o più dei suoi eventi. Ciò si ottiene attraverso una classe chiamata Livello , che definisce l'importanza della registrazione. Il livello di registro è ordinato e specificato da statico costanti intere, come:
- Livello.TUTTO: Tutti i messaggi vengono registrati, indipendentemente dall'importanza
- Livello.OFF: La registrazione è disattivata
- Livello.SEVERO: Indica un guasto grave; deve essere registrato
- Livello.AVVISO: Indica messaggi di avviso
- INFO.Livello: Messaggio informativo di runtime
- Livello.CONFIG: Messaggi di configurazione statici
- Livello.FINE: Tracciamento dei messaggi
- Livello.FINER: Messaggi di tracciamento dei dettagli
- Livello.FINEST: Messaggi di tracciamento altamente dettagliati
Componenti di registrazione
Abbiamo bisogno di un logger istanza per eseguire qualsiasi tipo di accesso in Java. Questa istanza è responsabile della registrazione dei dati in un LogRecord . Il Registro le istanze vengono utilizzate per passare le richieste di registrazione tra i framework di registrazione e i singoli gestori di log. Java SE fornisce cinque tipi di gestori integrati:StreamHandler , Gestione console , Gestione file , SocketHandler e MemoryHandler . Si può, tuttavia, creare un nuovo gestore o estenderne uno come personalizzazione. I gestori determinano cosa fare con il record di registro; ad esempio, può essere mantenuto in un repository locale o passarlo a un server su una rete. Java SE include anche due formattatori standard:SimpleFormatter e XMLFormatter . Questi formattatori vengono utilizzati per formattare un LogRecord rispettivamente in formato leggibile dall'uomo e in formato XML standard.
C'è un LogManager classe che tiene traccia delle informazioni di registrazione globali, come uno spazio dei nomi gerarchico di Logger denominati e una serie di proprietà di controllo della registrazione dal file di configurazione. È fondamentale per accedere a Java e controlla praticamente cosa registrare, dove registrare, inclusi altri dettagli di inizializzazione e così via.
Un semplice esempio di registrazione
Creazione di un logger oggetto è molto semplice. Ecco un codice molto semplice per illustrarlo.
import java.util.logging.Logger;
public class App {
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) {
logger.info("This is a log message !!!");
logger.info("The name of the logger is " +
logger.getName() + " nwhich is same as class name: "
+ App.class.getName());
}
}
Registratore di dati gli oggetti sono generalmente denominati utilizzando la Stringa valore di uno spazio dei nomi gerarchico separato da punti. Nel caso precedente, è uguale al nome della classe. Il nome, tuttavia, può essere un valore String arbitrario, ma normalmente i nomi sono basati sul nome del pacchetto o sul nome della classe del componente registrato. È inoltre possibile creare un logger “anonimo” che non verrà memorizzato nel Logger spazio dei nomi.
Accesso a un file esterno utilizzando la formattazione XML
Nel codice seguente, i messaggi di registro vengono reindirizzati a un file utilizzando FileHandler .
| Nota: Il file verrà creato nella directory del progetto. |
Il gestore di file può scrivere su un file specifico o può scrivere su un set di file rotante. Il set di file rotante significa che i file più vecchi vengono nominati aggiungendo 0,1,2 e così via nel nome del file di base. Il XMLFormatter è la formattazione predefinita utilizzata da FileHandler .
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
logger.addHandler(fileHandler);
logger.info("Log message redirected to a file");
logger.info("The name of the logger is " +
logger.getName() +
" nwhich is same as class name: "
+ App.class.getName());
}
}
Accesso a un file esterno utilizzando la formattazione personalizzata
Modificheremo leggermente il codice seguente per personalizzare la formattazione del messaggio. Questo cambia il modo in cui i messaggi vengono scritti nel file esterno.
| Nota: Osserva il contenuto del file di registro su come è cambiata la formattazione. |
import java.io.IOException;
import java.util.logging.*;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
fileHandler.setFormatter(newCustomFormatter());
logger.addHandler(fileHandler);
logger.fine("Log message redirected to a file");
logger.finer("The name of the logger is " +
logger.getName());
loggerfinest("This is same as class name: " +
App.class.getName());
}
private static class CustomFormatter extends Formatter {
private static final String format =
"[%1$tF %1$tT] [%2$-4s] %3$s %n";
public String format(LogRecord record) {
returnString.format(format,
record.getMillis(),
record.getLevel().getLocalizedName(),
record.getMessage());
}
}
}
È tutto. Sperimenta con la registrazione Java e prova molte altre possibilità. Consulta i documenti dell'API Java ove necessario.
Altri framework di registrazione in Java
A volte, è conveniente utilizzare un framework di registrazione di terze parti e ce ne sono alcuni popolari tra cui scegliere. Ad esempio, l'API di registrazione fornita da SLF4J utilizza un semplice pattern di facciata è un livello di astrazione che consente all'applicazione di essere disaccoppiata dal suo framework di registrazione. Log4j è sintatticamente simile alla registrazione Java integrata. Ha una configurazione predefinita per inviare tutti i messaggi di registro alla console. Logback è un successore di Log4j ed è un'estensione del suo predecessore. tinyLog è un framework di registrazione leggero che può essere utilizzato sia con Java che con Android.
Conclusione
Il processo di registrazione è progettato per essere semplice ed efficiente nel fornire ciò che dovrebbe fare. È possibile iniziare rapidamente con le API di registrazione in Java. Il design è estensibile e può essere personalizzato in base alle esigenze finali dello sviluppatore. Questo articolo offre uno sguardo alle basi della registrazione Java. Molti dettagli complessi vengono omessi per semplicità. Studia la documentazione dell'API Java e altri documenti appropriati per maggiori dettagli al riguardo.
Riferimenti
- Panoramica della registrazione Java
- Documentazione API Java
