log4j - Guida rapida

log4j è un framework di registrazione (API) affidabile, veloce e flessibile scritto in Java, distribuito sotto la licenza software Apache.

log4j è stato portato nei linguaggi C, C ++, C #, Perl, Python, Ruby e Eiffel.

log4j è altamente configurabile tramite file di configurazione esterni in fase di esecuzione. Visualizza il processo di registrazione in termini di livelli di priorità e offre meccanismi per indirizzare le informazioni di registrazione a una grande varietà di destinazioni, come un database, un file, una console, UNIX Syslog, ecc.

log4j ha tre componenti principali:

  • loggers: Responsabile dell'acquisizione delle informazioni di registrazione.

  • appenders: Responsabile della pubblicazione delle informazioni di registrazione in varie destinazioni preferite.

  • layouts: Responsabile della formattazione delle informazioni di registrazione in diversi stili.

Storia di log4j

  • Iniziato all'inizio del 1996 come API di tracciamento per il progetto EU SEMPER (Secure Electronic Marketplace for Europe).

  • Dopo innumerevoli miglioramenti e diverse incarnazioni, l'API iniziale si è evoluta fino a diventare log4j, un popolare pacchetto di registrazione per Java.

  • Il pacchetto è distribuito con la licenza software Apache, una licenza open source a tutti gli effetti certificata dall'iniziativa open source.

  • L'ultima versione di log4j, incluso il codice sorgente completo, i file di classe e la documentazione, è disponibile all'indirizzo http://logging.apache.org/log4j/.

Caratteristiche di log4j

  • È thread-safe.

  • È ottimizzato per la velocità.

  • Si basa su una gerarchia di logger denominata.

  • Supporta più appendici di output per logger.

  • Supporta l'internazionalizzazione.

  • Non è limitato a un insieme predefinito di servizi.

  • Il comportamento di registrazione può essere impostato in fase di esecuzione utilizzando un file di configurazione.

  • È progettato per gestire le eccezioni Java dall'inizio.

  • Usa più livelli, vale a dire ALL, TRACE, DEBUG, INFO, WARN, ERROR e FATAL.

  • Il formato dell'output del registro può essere facilmente modificato estendendo la classe Layout .

  • Il target dell'output del log e la strategia di scrittura possono essere modificati dalle implementazioni dell'interfaccia di Appender.

  • È fail-stop. Tuttavia, sebbene si sforzi certamente di garantire la consegna, log4j non garantisce che ogni istruzione di log verrà consegnata alla sua destinazione.

Pro e contro della registrazione

La registrazione è una componente importante dello sviluppo del software. Un codice di registrazione ben scritto offre un debug rapido, una facile manutenzione e un'archiviazione strutturata delle informazioni di runtime di un'applicazione.

Anche la registrazione ha i suoi svantaggi. Può rallentare un'applicazione. Se troppo prolisso, può causare cecità da scorrimento. Per alleviare queste preoccupazioni, log4j è progettato per essere affidabile, veloce ed estensibile.

Poiché la registrazione è raramente l'obiettivo principale di un'applicazione, l'API log4j si sforza di essere semplice da capire e da usare.

Il pacchetto API log4j è distribuito con la licenza software Apache, una licenza open source a tutti gli effetti certificata dall'iniziativa open source.

L'ultima versione di log4j, incluso il codice sorgente completo, i file di classe e la documentazione, è disponibile all'indirizzo http://logging.apache.org/log4j/.

Per installare log4j sul tuo sistema, scarica apache-log4j-xxxtar.gz dall'URL specificato e segui i passaggi indicati di seguito.

Passo 1

Decomprimere e decomprimere il file scaricato nella directory / usr / local / come segue:

$ gunzip apache-log4j-1.2.15.tar.gz
$ tar -xvf apache-log4j-1.2.15.tar
apache-log4j-1.2.15/tests/input/
apache-log4j-1.2.15/tests/input/xml/
apache-log4j-1.2.15/tests/src/
apache-log4j-1.2.15/tests/src/java/
apache-log4j-1.2.15/tests/src/java/org/
.......................................

Pur disarmando, creerebbe una gerarchia di directory con un nome apache-log4j-xxx come segue:

-rw-r--r--  1 root root   3565 2007-08-25 00:09 BUILD-INFO.txt
-rw-r--r--  1 root root   2607 2007-08-25 00:09 build.properties.sample
-rw-r--r--  1 root root  32619 2007-08-25 00:09 build.xml
drwxr-xr-x 14 root root   4096 2010-02-04 14:09 contribs
drwxr-xr-x  5 root root   4096 2010-02-04 14:09 examples
-rw-r--r--  1 root root   2752 2007-08-25 00:09 INSTALL
-rw-r--r--  1 root root   4787 2007-08-25 00:09 KEYS
-rw-r--r--  1 root root  11366 2007-08-25 00:09 LICENSE
-rw-r--r--  1 root root 391834 2007-08-25 00:29 log4j-1.2.15.jar
-rw-r--r--  1 root root    160 2007-08-25 00:09 NOTICE
-rwxr-xr-x  1 root root  10240 2007-08-25 00:27 NTEventLogAppender.dll
-rw-r--r--  1 root root  17780 2007-08-25 00:09 pom.xml
drwxr-xr-x  7 root root   4096 2007-08-25 00:13 site
drwxr-xr-x  8 root root   4096 2010-02-04 14:08 src
drwxr-xr-x  6 root root   4096 2010-02-04 14:09 tests

Passo 2

Questo passaggio è facoltativo e dipende dalle funzionalità che utilizzerai dal framework log4j. Se hai già i seguenti pacchetti installati sulla tua macchina, allora va bene, altrimenti devi installarli per far funzionare log4j.

  • JavaMail API:La funzione di registrazione basata sulla posta elettronica in log4j richiede l'installazione di Java Mail API (mail.jar) sulla macchina da glassfish.dev .

  • JavaBeans Activation Framework: L'API Java Mail richiederà anche l'installazione di JavaBeans Activation Framework (activation.jar) sulla macchina da http://java.sun.com/products/javabeans/jaf/index.jsp.

  • Java Message Service: Le funzioni compatibili con JMS di log4j richiederanno che sia JMS che Java Naming e Directory Interface JNDI siano installati sulla macchina da http://java.sun.com/products/jms.

  • XML Parser:È necessario un parser XML compatibile con JAXP per utilizzare log4j. Assicurati di avere Xerces.jar installato sulla tua macchina dahttp://xerces.apache.org/xerces-j/install.html.

Passaggio 3

Ora devi configurare il file CLASSPATH e PATHvariabili in modo appropriato. Qui lo imposteremo solo per il file log4j.xxxjar.

$ pwd
/usr/local/apache-log4j-1.2.15
$ export CLASSPATH= \
      $CLASSPATH:/usr/local/apache-log4j-1.2.15/log4j-1.2.15.jar
$ export PATH=$PATH:/usr/local/apache-log4j-1.2.15/

L'API log4j segue un'architettura a più livelli in cui ogni livello fornisce oggetti diversi per eseguire attività diverse. Questa architettura a strati rende il design flessibile e facile da estendere in futuro.

Sono disponibili due tipi di oggetti con il framework log4j.

  • Core Objects:Questi sono oggetti obbligatori del framework. Sono necessari per utilizzare il framework.

  • Support Objects:Questi sono oggetti opzionali del framework. Supportano gli oggetti principali per eseguire attività aggiuntive ma importanti.

Oggetti fondamentali

Gli oggetti principali includono i seguenti tipi di oggetti:

Oggetto logger

Il livello di primo livello è il Logger che fornisce l'oggetto Logger. L'oggetto Logger è responsabile dell'acquisizione delle informazioni di registrazione e vengono archiviate in una gerarchia dello spazio dei nomi.

Oggetto layout

Il livello di layout fornisce oggetti che vengono utilizzati per formattare le informazioni di registrazione in stili diversi. Fornisce supporto agli oggetti appender prima di pubblicare le informazioni di registrazione.

Gli oggetti del layout svolgono un ruolo importante nella pubblicazione delle informazioni di registrazione in modo leggibile e riutilizzabile.

Oggetto appender

Questo è un livello di livello inferiore che fornisce oggetti Appender. L'oggetto Appender è responsabile della pubblicazione delle informazioni di registrazione su varie destinazioni preferite come database, file, console, UNIX Syslog, ecc.

Il seguente diagramma virtuale mostra i componenti di un framework log4J:

Oggetti di supporto

Ci sono altri oggetti importanti nel framework log4j che svolgono un ruolo vitale nel framework di registrazione:

Oggetto livello

L'oggetto Level definisce la granularità e la priorità di qualsiasi informazione di registrazione. Esistono sette livelli di registrazione definiti all'interno dell'API: OFF, DEBUG, INFO, ERROR, WARN, FATAL e ALL.

Oggetto filtro

L'oggetto Filter viene utilizzato per analizzare le informazioni di registrazione e prendere ulteriori decisioni sull'opportunità di registrare o meno tali informazioni.

A un oggetto Appender possono essere associati diversi oggetti Filtro. Se le informazioni di registrazione vengono passate a un particolare oggetto Appender, tutti gli oggetti Filtro associati a tale Appender devono approvare le informazioni di registrazione prima di poter essere pubblicate nella destinazione allegata.

ObjectRenderer

L'oggetto ObjectRenderer è specializzato nel fornire una rappresentazione String di diversi oggetti passati al framework di registrazione. Questo oggetto viene utilizzato dagli oggetti Layout per preparare le informazioni di registrazione finali.

LogManager

L'oggetto LogManager gestisce il framework di registrazione. È responsabile della lettura dei parametri di configurazione iniziale da un file di configurazione a livello di sistema o da una classe di configurazione.

Il capitolo precedente ha spiegato i componenti principali di log4j. Questo capitolo spiega come configurare i componenti principali utilizzando un file di configurazione. La configurazione di log4j implica l'assegnazione del Livello, la definizione dell'Appender e la specifica degli oggetti Layout in un file di configurazione.

Il file log4j.properties è un file di configurazione log4j che mantiene le proprietà in coppie chiave-valore. Per impostazione predefinita, LogManager cerca un file denominato log4j.properties nel fileCLASSPATH.

  • Il livello del logger root è definito come DEBUG. Il DEBUG vi allega l'appender denominato X.

  • Imposta l'appender denominato X come appender valido.

  • Imposta il layout per l'appender X.

log4j.properties Sintassi:

Di seguito è riportata la sintassi del file log4j.properties per un appender X:

# Define the root logger with appender X
log4j.rootLogger = DEBUG, X

# Set the appender named X to be a File appender
log4j.appender.X=org.apache.log4j.FileAppender

# Define the layout for X appender
log4j.appender.X.layout=org.apache.log4j.PatternLayout
log4j.appender.X.layout.conversionPattern=%m%n

log4j.properties Esempio

Utilizzando la sintassi precedente, definiamo quanto segue nel file log4j.properties :

  • Il livello del logger root è definito come DEBUG, l'appender DEBUG denominato FILE ad esso.

  • Il FILE dell'appender è definito come org.apache.log4j.FileAppender . Scrive in un file denominato "log.out" situato nellog directory.

  • Il modello di layout definito è % m% n , il che significa che il messaggio di registrazione stampato sarà seguito da un carattere di nuova riga.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

È importante notare che log4j supporta la sostituzione di variabili in stile UNIX come $ {variableName}.

Livello di debug

Abbiamo usato DEBUG con entrambe le appendici. Tutte le opzioni possibili sono:

  • TRACE
  • DEBUG
  • INFO
  • WARN
  • ERROR
  • FATAL
  • ALL

Questi livelli verranno spiegati in Log4j Logging Levels .

Appendici

Apache log4j fornisce oggetti Appender che sono i principali responsabili della stampa di messaggi di log su diverse destinazioni come console, file, socket, log eventi NT, ecc.

Ogni oggetto Appender ha proprietà differenti ad esso associate e queste proprietà indicano il comportamento di quell'oggetto.

Proprietà Descrizione
disposizione Appender utilizza gli oggetti Layout e il modello di conversione ad essi associato per formattare le informazioni di registrazione.
bersaglio Il target può essere una console, un file o un altro elemento a seconda dell'appender.
livello Il livello è necessario per controllare il filtraggio dei messaggi di registro.
soglia All'appender può essere associato un livello di soglia indipendentemente dal livello di logger. L'Appender ignora tutti i messaggi di registrazione che hanno un livello inferiore al livello di soglia.
filtro Gli oggetti Filter possono analizzare le informazioni di registrazione oltre la corrispondenza dei livelli e decidere se le richieste di registrazione devono essere gestite da un particolare Appender o ignorate.

Possiamo aggiungere un oggetto Appender a un Logger includendo la seguente impostazione nel file di configurazione con il seguente metodo:

log4j.logger.[logger-name]=level, appender1,appender..n

È possibile scrivere la stessa configurazione in formato XML come segue:

<logger name="com.apress.logging.log4j" additivity="false">
   <appender-ref ref="appender1"/>
   <appender-ref ref="appender2"/>
</logger>

Se sei disposto ad aggiungere un oggetto Appender all'interno del tuo programma, puoi utilizzare il seguente metodo:

public void addAppender(Appender appender);

Il metodo addAppender () aggiunge un Appender all'oggetto Logger. Come dimostra la configurazione di esempio, è possibile aggiungere molti oggetti Appender a un logger in un elenco separato da virgole, ciascuno stampando le informazioni di registrazione su destinazioni separate.

Abbiamo utilizzato un solo appender FileAppender nel nostro esempio sopra. Tutte le possibili opzioni di appender sono:

  • AppenderSkeleton
  • AsyncAppender
  • ConsoleAppender
  • DailyRollingFileAppender
  • ExternallyRolledFileAppender
  • FileAppender
  • JDBCAppender
  • JMSAppender
  • LF5Appender
  • NTEventLogAppender
  • NullAppender
  • RollingFileAppender
  • SMTPAppender
  • SocketAppender
  • SocketHubAppender
  • SyslogAppender
  • TelnetAppender
  • WriterAppender

Copriremo FileAppender in Accesso ai file e JDBC Appender sarebbe trattato in Accesso al database .

disposizione

Abbiamo utilizzato PatternLayout con il nostro appender. Tutte le opzioni possibili sono:

  • DateLayout
  • HTMLLayout
  • PatternLayout
  • SimpleLayout
  • XMLLayout

Utilizzando HTMLLayout e XMLLayout, puoi generare log in HTML e anche in formato XML.

Formattazione del layout

Imparerai come formattare un messaggio di registro nel capitolo: Formattazione registro .

Abbiamo visto come creare un file di configurazione. Questo capitolo descrive come generare messaggi di debug e registrarli in un semplice file di testo.

Di seguito è riportato un semplice file di configurazione creato per il nostro esempio. Rivediamolo ancora una volta:

  • Il livello del logger root è definito come DEBUG e vi allega l'appender denominato FILE.

  • L'appender FILE è definito come org.apache.log4j.FileAppender e scrive in un file denominato "log.out" situato nel log directory.

  • Il modello di layout definito è% m% n, il che significa che il messaggio di registrazione stampato sarà seguito da un carattere di nuova riga.

I contenuti del file log4j.properties sono i seguenti:

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Utilizzo di log4j nel programma Java

La seguente classe Java è un esempio molto semplice che inizializza e quindi utilizza la libreria di registrazione Log4J per le applicazioni Java.

import org.apache.log4j.Logger;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Compila ed esegui

Ecco i passaggi per compilare ed eseguire il programma sopra menzionato. Assicurati di aver impostatoPATH e CLASSPATH opportunamente prima di procedere per la compilazione e l'esecuzione.

Tutte le librerie dovrebbero essere disponibili in CLASSPATHe il file log4j.properties dovrebbe essere disponibile in PATH. Segui i passaggi indicati di seguito:

  • Crea log4j.properties come mostrato sopra.

  • Crea log4jExample.java come mostrato sopra e compilarlo.

  • Esegui log4jExample binary per eseguire il programma.

Si otterrebbe il seguente risultato all'interno del file /usr/home/log4j/log.out:

Hello this is a debug message
Hello this is an info message

La classe Logger fornisce una varietà di metodi per gestire le attività di registrazione. La classe Logger non ci consente di creare un'istanza di una nuova istanza Logger ma fornisce due metodi statici per ottenere un oggetto Logger:

  • public static Logger getRootLogger();
  • public static Logger getLogger(String name);

Il primo dei due metodi restituisce il logger principale dell'istanza dell'applicazione e non ha un nome.

Qualsiasi altra istanza di oggetto Logger denominata viene ottenuta tramite il secondo metodo passando il nome del logger. Il nome del logger può essere qualsiasi stringa che puoi passare, di solito una classe o un nome di pacchetto come abbiamo usato nell'ultimo capitolo ed è menzionato di seguito:

static Logger log = Logger.getLogger(log4jExample.class.getName());

Metodi di registrazione

Una volta ottenuta un'istanza di un logger denominato, possiamo utilizzare diversi metodi del logger per registrare i messaggi. La classe Logger dispone dei seguenti metodi per stampare le informazioni di registrazione.

Suor n Metodi e descrizione
1 public void debug(Object message)

Stampa messaggi con il livello Level.DEBUG.
2 public void error(Object message)

Stampa messaggi con il livello Level.ERROR.
3 public void fatal(Object message);

Stampa messaggi con il livello Level.FATAL.
4 public void info(Object message);

Stampa messaggi con il livello Level.INFO.
5 public void warn(Object message);

Stampa messaggi con il livello Level.WARN.
6 public void trace(Object message);

Stampa messaggi con il livello Level.TRACE.

Tutti i livelli sono definiti nella classe org.apache.log4j.Level e uno qualsiasi dei metodi sopra menzionati può essere chiamato come segue:

import org.apache.log4j.Logger;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Quando compili ed esegui il programma LogClass, viene generato il seguente risultato:

Debug Message!
Info Message!
Warn Message!
Error Message!
Fatal Message!

Tutti i messaggi di debug hanno più senso se usati in combinazione con i livelli. Tratteremo i livelli nel prossimo capitolo e quindi avresti una buona comprensione di come utilizzare questi metodi in combinazione con diversi livelli di debug.

La classe org.apache.log4j.Level fornisce i seguenti livelli. Puoi anche definire i tuoi livelli personalizzati sottoclassando la classe Level.

Livello Descrizione
TUTTI Tutti i livelli, compresi i livelli personalizzati.
DEBUG Indica eventi informativi a grana fine più utili per eseguire il debug di un'applicazione.
INFORMAZIONI Indica messaggi informativi che evidenziano l'avanzamento dell'applicazione a livello grossolano.
AVVISARE Indica situazioni potenzialmente dannose.
ERRORE Indica eventi di errore che potrebbero ancora consentire all'applicazione di continuare l'esecuzione.
FATALE Indica eventi di errore molto gravi che presumibilmente porteranno l'applicazione a interrompersi.
OFF Il grado più alto possibile ed è destinato a disattivare la registrazione.
TRACCIA Indica eventi informativi a grana più fine rispetto a DEBUG.

Come funzionano i livelli?

Una richiesta di registro di livello p in un logger con livello qè abilitato se p> = q. Questa regola è al centro di log4j. Si presuppone che i livelli siano ordinati. Per i livelli standard, abbiamo ALL <DEBUG <INFO <WARN <ERROR <FATAL <OFF.

L'esempio seguente mostra come filtrare tutti i nostri messaggi DEBUG e INFO. Questo programma utilizza il metodo di registrazione setLevel (Level.X) per impostare un livello di registrazione desiderato:

Questo esempio stampa tutti i messaggi tranne Debug e Info:

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.setLevel(Level.WARN);

      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Quando compili ed esegui il programma LogClass, verrà generato il seguente risultato:

Warn Message!
Error Message!
Fatal Message!

Impostazione dei livelli utilizzando il file di configurazione

log4j fornisce un'impostazione del livello basata sul file di configurazione che ti libera dalla modifica del codice sorgente quando desideri modificare il livello di debug.

Di seguito è riportato un file di configurazione di esempio che eseguirà la stessa operazione eseguita utilizzando il metodo log.setLevel (Level.WARN) nell'esempio precedente.

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = WARN, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Usiamo ora il nostro programma seguente:

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Ora compila ed esegui il programma sopra e otterrai il seguente risultato nel file /usr/home/log4j/log.out:

Warn Message!
Error Message!
Fatal Message!

Apache log4j fornisce vari oggetti Layout, ognuno dei quali può formattare i dati di registrazione in base a vari layout. È anche possibile creare un oggetto Layout che formatta i dati di registrazione in un modo specifico dell'applicazione.

Tutti gli oggetti Layout ricevono un oggetto LoggingEvent dagli oggetti Appender. Gli oggetti Layout quindi recuperano l'argomento del messaggio da LoggingEvent e applicano l'ObjectRenderer appropriato per ottenere la rappresentazione String del messaggio.

I tipi di layout

La classe di primo livello nella gerarchia è la classe astratta org.apache.log4j.Layout. Questa è la classe base per tutte le altre classi Layout nell'API log4j.

La classe Layout è definita astratta all'interno di un'applicazione, non usiamo mai questa classe direttamente; invece, lavoriamo con le sue sottoclassi che sono le seguenti:

I metodi di layout

Questa classe fornisce un'implementazione scheletrica di tutte le operazioni comuni tra tutti gli altri oggetti Layout e dichiara due metodi astratti.

Sr.No. Metodi e descrizione
1 public abstract boolean ignoresThrowable()

Indica se le informazioni di registrazione gestiscono qualsiasi oggetto java.lang.Throwable passato ad essa come parte dell'evento di registrazione. Se l'oggetto Layout gestisce l'oggetto Throwable, l'oggetto Layout non lo ignora e restituisce false.
2 public abstract String format(LoggingEvent event)

Le singole sottoclassi di layout implementano questo metodo per la formattazione specifica del layout.

Oltre a questi metodi astratti, la classe Layout fornisce un'implementazione concreta per i metodi elencati di seguito:

Sr.No. Metodi e descrizione
1 public String getContentType()

Restituisce il tipo di contenuto utilizzato dagli oggetti Layout. La classe base restituisce text / plain come tipo di contenuto predefinito.
2 public String getFooter()

Specifica le informazioni nel piè di pagina del messaggio di registrazione.
3 public String getHeader()

Specifica le informazioni di intestazione del messaggio di registrazione.

Ogni sottoclasse può restituire informazioni specifiche della classe sovrascrivendo l'implementazione concreta di questi metodi.

Per scrivere le informazioni di registrazione in un file, è necessario utilizzare org.apache.log4j.FileAppender .

Configurazione di FileAppender

FileAppender ha i seguenti parametri configurabili:

Proprietà Descrizione
immediatoFlush Questo flag è impostato per impostazione predefinita su true, il che significa che il flusso di output del file viene scaricato con ogni operazione di accodamento.
codifica È possibile utilizzare qualsiasi codifica dei caratteri. Per impostazione predefinita, è lo schema di codifica specifico della piattaforma.
soglia Il livello di soglia per questo appender.
Nome del file Il nome del file di registro.
fileAppend L'impostazione predefinita è true, il che significa che le informazioni di registrazione vengono aggiunte alla fine dello stesso file.
bufferedIO Questo flag indica se è necessaria la scrittura bufferizzata abilitata. Per impostazione predefinita, è impostato su false.
dimensione buffer Se l'I / O bufferizzato è abilitato, indica la dimensione del buffer. Per impostazione predefinita, è impostato su 8kb.

Di seguito è riportato un file di configurazione di esempio log4j.properties per FileAppender.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, overwrite
log4j.appender.FILE.Append=false

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Se desideri avere un file di configurazione XML equivalente al file log4j.properties sopra , ecco il contenuto:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="FILE" class="org.apache.log4j.FileAppender">
   <param name="file" value="${log}/log.out"/>
   <param name="immediateFlush" value="true"/>
   <param name="threshold" value="debug"/>
   <param name="append" value="false"/>
   <layout class="org.apache.log4j.PatternLayout">
      <param name="conversionPattern" value="%m%n"/>
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="FILE"/>
</logger>

</log4j:configuration>

Puoi provare log4j - Programma di esempio con la configurazione di cui sopra.

Accesso a più file

Potresti voler scrivere i tuoi messaggi di log in più file per determinati motivi, ad esempio, se la dimensione del file ha raggiunto una certa soglia.

Per scrivere le informazioni di registrazione in più file, è necessario utilizzare la classe org.apache.log4j.RollingFileAppender che estende la classe FileAppender ed eredita tutte le sue proprietà.

Abbiamo i seguenti parametri configurabili oltre a quelli sopra menzionati per FileAppender:

Proprietà Descrizione
maxFileSize Questa è la dimensione critica del file al di sopra della quale il file verrà spostato. Il valore predefinito è 10 MB.
maxBackupIndex Questa proprietà denota il numero di file di backup da creare. Il valore predefinito è 1.

Di seguito è riportato un file di configurazione di esempio log4j.properties per RollingFileAppender.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.RollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the maximum file size before rollover
log4j.appender.FILE.MaxFileSize=5MB

# Set the the backup index
log4j.appender.FILE.MaxBackupIndex=2

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Se desideri avere un file di configurazione XML, puoi generare lo stesso menzionato nella sezione iniziale e aggiungere solo parametri aggiuntivi relativi a RollingFileAppender .

Questa configurazione di esempio dimostra che la dimensione massima consentita di ogni file di registro è 5 MB. Al superamento della dimensione massima, verrà creato un nuovo file di registro. Poiché maxBackupIndex è definito come 2, una volta che il secondo file di registro raggiunge la dimensione massima, il primo file di registro verrà cancellato e, successivamente, tutte le informazioni di registrazione verranno riportate al primo file di registro.

Puoi provare log4j - Programma di esempio con la configurazione di cui sopra.

Generazione giornaliera di file di registro

Potrebbe essere necessario generare i file di registro su base giornaliera per mantenere un registro pulito delle informazioni di registrazione.

Per scrivere le tue informazioni di registrazione nei file su base giornaliera, dovresti usare la classe org.apache.log4j.DailyRollingFileAppender che estende la classe FileAppender ed eredita tutte le sue proprietà.

C'è solo un importante parametro configurabile oltre a quelli sopra menzionati per FileAppender:

Proprietà Descrizione
DatePattern Indica quando eseguire il rollover del file e la convenzione di denominazione da seguire. Per impostazione predefinita, il rollover viene eseguito a mezzanotte ogni giorno.

DatePattern controlla la pianificazione del rollover utilizzando uno dei seguenti modelli:

DatePattern Descrizione
"." aaaa-MM Rollover alla fine di ogni mese e all'inizio del mese successivo.
"." aaaa-MM-gg Rollover a mezzanotte ogni giorno. Questo è il valore predefinito.
"." aaaa-MM-gg-a Rollover a mezzogiorno e mezzanotte di ogni giorno.
"." aaaa-MM-gg-HH Rotola sopra ogni ora.
"." aaaa-MM-gg-HH-mm Rotola ogni minuto.
"." yyyy-ww Rollover il primo giorno di ogni settimana a seconda della località.

Di seguito è riportato un file di configurazione di esempio log4j.properties per generare file di registro che si alternano a mezzogiorno e mezzanotte di ogni giorno.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the DatePattern
log4j.appender.FILE.DatePattern='.' yyyy-MM-dd-a

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Se desideri avere un file di configurazione XML, puoi generare lo stesso menzionato nella sezione iniziale e aggiungere solo parametri aggiuntivi relativi a DailyRollingFileAppender .

Puoi provare log4j - Programma di esempio con la configurazione di cui sopra.

L'API log4j fornisce l' oggetto org.apache.log4j.jdbc.JDBCAppender , che può inserire le informazioni di registrazione in un database specificato.

Configurazione JDBCAppender

Proprietà Descrizione
dimensione buffer Imposta la dimensione del buffer. La dimensione predefinita è 1.
conducente Imposta la classe del driver sulla stringa specificata. Se non è specificata alcuna classe driver, il valore predefinito è sun.jdbc.odbc.JdbcOdbcDriver.
disposizione Imposta il layout da utilizzare. Il layout predefinito è org.apache.log4j.PatternLayout.
parola d'ordine Imposta la password del database.
sql Specifica l'istruzione SQL da eseguire ogni volta che si verifica un evento di registrazione. Potrebbe essere INSERT, UPDATE o DELETE.
URL Imposta l'URL JDBC.
utente Imposta il nome utente del database.

Configurazione della tabella di registro

Prima di iniziare a utilizzare la registrazione basata su JDBC, è necessario creare una tabella per conservare tutte le informazioni di registro. Di seguito è riportata l'istruzione SQL per la creazione della tabella LOGS:

CREATE TABLE LOGS
   (USER_ID VARCHAR(20) NOT NULL,
    DATED   DATE NOT NULL,
    LOGGER  VARCHAR(50) NOT NULL,
    LEVEL   VARCHAR(10) NOT NULL,
    MESSAGE VARCHAR(1000) NOT NULL
   );

File di configurazione di esempio

Di seguito è riportato un file di configurazione di esempio log4j.properties per JDBCAppender che verrà utilizzato per registrare i messaggi in una tabella LOGS.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, DB

# Define the DB appender
log4j.appender.DB=org.apache.log4j.jdbc.JDBCAppender

# Set JDBC URL
log4j.appender.DB.URL=jdbc:mysql://localhost/DBNAME

# Set Database Driver
log4j.appender.DB.driver=com.mysql.jdbc.Driver

# Set database user name and password
log4j.appender.DB.user=user_name
log4j.appender.DB.password=password

# Set the SQL statement to be executed.
log4j.appender.DB.sql=INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')

# Define the layout for file appender
log4j.appender.DB.layout=org.apache.log4j.PatternLayout

Per il database MySQL, dovresti usare il DBNAME, l'ID utente e la password effettivi, dove hai creato la tabella LOGS. L'istruzione SQL deve eseguire un'istruzione INSERT con il nome della tabella LOGS ei valori da inserire nella tabella.

JDBCAppender non necessita di un layout da definire in modo esplicito. Invece, l'istruzione SQL passata utilizza un PatternLayout.

Se desideri avere un file di configurazione XML equivalente al file log4j.properties sopra , ecco il contenuto:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="DB" class="org.apache.log4j.jdbc.JDBCAppender">
   <param name="url" value="jdbc:mysql://localhost/DBNAME"/>
   <param name="driver" value="com.mysql.jdbc.Driver"/>
   <param name="user" value="user_id"/>
   <param name="password" value="password"/>
   <param name="sql" value="INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')"/>
   <layout class="org.apache.log4j.PatternLayout">
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="DB"/>
</logger>

</log4j:configuration>

Programma di esempio

La seguente classe Java è un esempio molto semplice che inizializza e quindi utilizza la libreria di registrazione Log4J per le applicazioni Java.

import org.apache.log4j.Logger;
import java.sql.*;
import java.io.*;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Debug");
      log.info("Info");
   }
}

Compila ed esegui

Ecco i passaggi per compilare ed eseguire il programma sopra menzionato. Assicurati di aver impostatoPATH e CLASSPATH opportunamente prima di procedere alla compilazione e all'esecuzione.

Tutte le librerie dovrebbero essere disponibili in CLASSPATHe il file log4j.properties dovrebbe essere disponibile in PATH. Segui i passaggi indicati:

  • Crea log4j.properties come mostrato sopra.
  • Crea log4jExample.java come mostrato sopra e compilarlo.
  • Esegui log4jExample binary per eseguire il programma.

Ora controlla la tua tabella LOGS all'interno del database DBNAME e troverai le seguenti voci:

mysql >  select * from LOGS;
+---------+------------+--------------+-------+---------+
| USER_ID | DATED      | LOGGER       | LEVEL | MESSAGE |
+---------+------------+--------------+-------+---------+
|         | 2010-05-13 | log4jExample | DEBUG | Debug   |
|         | 2010-05-13 | log4jExample | INFO  | Info    |
+---------+------------+--------------+-------+---------+
2 rows in set (0.00 sec)

Note:Qui x viene utilizzato per produrre il contesto diagnostico annidato (NDC) associato al thread che ha generato l'evento di registrazione. Usiamo NDC per distinguere i client in componenti lato server che gestiscono più client. Controllare il manuale di Log4J per ulteriori informazioni su questo.