log4j - Guía rápida

log4j es un marco de registro (API) confiable, rápido y flexible escrito en Java, que se distribuye bajo la licencia de software Apache.

log4j se ha adaptado a los lenguajes C, C ++, C #, Perl, Python, Ruby y Eiffel.

log4j es altamente configurable a través de archivos de configuración externos en tiempo de ejecución. Ve el proceso de registro en términos de niveles de prioridades y ofrece mecanismos para dirigir la información de registro a una gran variedad de destinos, como una base de datos, archivo, consola, UNIX Syslog, etc.

log4j tiene tres componentes principales:

loggers: Responsable de capturar la información de registro.
appenders: Responsable de publicar información de registro en varios destinos preferidos.
layouts: Responsable de formatear la información de registro en diferentes estilos.

Historia de log4j

Comenzó a principios de 1996 como API de rastreo para el proyecto EU SEMPER (Mercado electrónico seguro para Europa).
Después de innumerables mejoras y varias encarnaciones, la API inicial ha evolucionado para convertirse en log4j, un paquete de registro popular para Java.
El paquete se distribuye bajo la licencia de software Apache, una licencia de código abierto de pleno derecho certificada por la iniciativa de código abierto.
La última versión de log4j, incluido su código fuente completo, archivos de clase y documentación, se puede encontrar en http://logging.apache.org/log4j/.

Características de log4j

Es seguro para subprocesos.
Está optimizado para la velocidad.
Se basa en una jerarquía de registradores con nombre.
Admite múltiples agregadores de salida por registrador.
Apoya la internacionalización.
No está restringido a un conjunto predefinido de instalaciones.
El comportamiento de registro se puede configurar en tiempo de ejecución mediante un archivo de configuración.
Está diseñado para manejar excepciones de Java desde el principio.
Utiliza múltiples niveles, a saber, TODOS, RASTREO, DEPURACIÓN, INFORMACIÓN, ADVERTENCIA, ERROR y FATAL.
El formato de la salida del registro se puede cambiar fácilmente ampliando la clase Layout .
El destino de la salida del registro, así como la estrategia de escritura, pueden modificarse mediante implementaciones de la interfaz Appender.
Es una parada de emergencia. Sin embargo, aunque ciertamente se esfuerza por garantizar la entrega, log4j no garantiza que cada declaración de registro se envíe a su destino.

Pros y contras de la tala

El registro es un componente importante del desarrollo de software. Un código de registro bien escrito ofrece una depuración rápida, un mantenimiento sencillo y un almacenamiento estructurado de la información en tiempo de ejecución de una aplicación.

La tala también tiene sus inconvenientes. Puede ralentizar una aplicación. Si es demasiado detallado, puede causar ceguera de desplazamiento. Para aliviar estas preocupaciones, log4j está diseñado para ser confiable, rápido y extensible.

Dado que el registro rara vez es el enfoque principal de una aplicación, la API de log4j se esfuerza por ser simple de entender y usar.

El paquete API log4j se distribuye bajo la licencia de software Apache, una licencia de código abierto completa certificada por la iniciativa de código abierto.

La última versión de log4j, incluido el código fuente completo, los archivos de clase y la documentación se puede encontrar en http://logging.apache.org/log4j/.

Para instalar log4j en su sistema, descargue apache-log4j-xxxtar.gz desde la URL especificada y siga los pasos que se indican a continuación.

Paso 1

Descomprima y descomprima el archivo descargado en el directorio / usr / local / de la siguiente manera:

$ 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/
.......................................

Mientras se deshace, crearía una jerarquía de directorios con un nombre apache-log4j-xxx de la siguiente manera:

-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

Paso 2

Este paso es opcional y depende de las funciones que vaya a utilizar en el marco log4j. Si ya tiene los siguientes paquetes instalados en su máquina, entonces está bien; de lo contrario, debe instalarlos para que log4j funcione.

JavaMail API:La función de registro basada en correo electrónico en log4j requiere que la API de correo de Java (mail.jar) esté instalada en su máquina desde glassfish.dev .
JavaBeans Activation Framework: La API de Java Mail también requerirá que el marco de activación de JavaBeans (activación.jar) esté instalado en su máquina desde http://java.sun.com/products/javabeans/jaf/index.jsp.
Java Message Service: Las características compatibles con JMS de log4j requerirán que tanto JMS como Java Naming and Directory Interface JNDI estén instalados en su máquina desde http://java.sun.com/products/jms.
XML Parser:Necesita un analizador XML compatible con JAXP para utilizar log4j. Asegúrese de tener Xerces.jar instalado en su máquina desdehttp://xerces.apache.org/xerces-j/install.html.

Paso 3

Ahora necesitas configurar el CLASSPATH y PATHvariables apropiadamente. Aquí lo configuraremos solo para el archivo 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/

La API de log4j sigue una arquitectura en capas donde cada capa proporciona diferentes objetos para realizar diferentes tareas. Esta arquitectura en capas hace que el diseño sea flexible y fácil de ampliar en el futuro.

Hay dos tipos de objetos disponibles con el marco log4j.

Core Objects:Estos son objetos obligatorios del marco. Deben utilizar el marco.
Support Objects:Estos son objetos opcionales del marco. Apoyan los objetos centrales para realizar tareas adicionales pero importantes.

Objetos centrales

Los objetos principales incluyen los siguientes tipos de objetos:

Objeto registrador

La capa de nivel superior es el registrador que proporciona el objeto registrador. El objeto Logger es responsable de capturar la información de registro y se almacena en una jerarquía de espacio de nombres.

Objeto de diseño

La capa de diseño proporciona objetos que se utilizan para formatear la información de registro en diferentes estilos. Proporciona soporte a los objetos añadidos antes de publicar la información de registro.

Los objetos de diseño juegan un papel importante en la publicación de información de registro de una manera que sea legible y reutilizable.

Objeto de adición

Esta es una capa de nivel inferior que proporciona objetos Appender. El objeto Appender es responsable de publicar información de registro en varios destinos preferidos, como una base de datos, un archivo, una consola, UNIX Syslog, etc.

El siguiente diagrama virtual muestra los componentes de un marco log4J:

Objetos de apoyo

Hay otros objetos importantes en el marco log4j que juegan un papel vital en el marco de registro:

Objeto de nivel

El objeto Level define la granularidad y la prioridad de cualquier información de registro. Hay siete niveles de registro definidos dentro de la API: OFF, DEBUG, INFO, ERROR, WARN, FATAL y ALL.

Objeto de filtro

El objeto Filtro se utiliza para analizar la información de registro y tomar decisiones adicionales sobre si esa información debe registrarse o no.

Un objeto Appender puede tener varios objetos Filter asociados con ellos. Si la información de registro se pasa a un objeto de Appender en particular, todos los objetos de filtro asociados con ese Appender deben aprobar la información de registro antes de que se pueda publicar en el destino adjunto.

ObjectRenderer

El objeto ObjectRenderer está especializado en proporcionar una representación de cadena de diferentes objetos pasados al marco de registro. Los objetos Layout utilizan este objeto para preparar la información de registro final.

LogManager

El objeto LogManager gestiona el marco de registro. Es responsable de leer los parámetros de configuración inicial de un archivo de configuración de todo el sistema o una clase de configuración.

El capítulo anterior explicó los componentes centrales de log4j. Este capítulo explica cómo configurar los componentes principales mediante un archivo de configuración. La configuración de log4j implica asignar el nivel, definir el appender y especificar los objetos de diseño en un archivo de configuración.

El archivo log4j.properties es un archivo de configuración log4j que mantiene las propiedades en pares clave-valor. De forma predeterminada, LogManager busca un archivo llamado log4j.properties en elCLASSPATH.

El nivel del registrador raíz se define como DEBUG. El DEBUG le adjunta el appender llamado X.
Configure el appender llamado X para que sea un appender válido.
Establezca el diseño del appender X.

Sintaxis de log4j.properties:

A continuación se muestra la sintaxis del archivo log4j.properties para 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

Ejemplo de log4j.properties

Usando la sintaxis anterior, definimos lo siguiente en el archivo log4j.properties :

El nivel del registrador raíz se define como DEBUG, el appender DEBUG llamado FILE.
El ARCHIVO del appender se define como org.apache.log4j.FileAppender . Escribe en un archivo llamado "log.out" ubicado en ellog directorio.
El patrón de diseño definido es % m% n , lo que significa que el mensaje de registro impreso será seguido por un carácter de nueva línea.

# 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

Es importante tener en cuenta que log4j admite la sustitución de variables de estilo UNIX como $ {variableName}.

Nivel de depuración

Hemos utilizado DEBUG con ambos añadidos. Todas las opciones posibles son:

TRACE
DEBUG
INFO
WARN
ERROR
FATAL
ALL

Estos niveles se explicarán en log4j Logging Levels .

Anexos

Apache log4j proporciona objetos Appender que son los principales responsables de imprimir mensajes de registro a diferentes destinos, como consolas, archivos, sockets, registros de eventos de NT, etc.

Cada objeto Appender tiene diferentes propiedades asociadas a él, y estas propiedades indican el comportamiento de ese objeto.

Propiedad	Descripción
diseño	Appender usa los objetos Layout y el patrón de conversión asociado con ellos para formatear la información de registro.
objetivo	El destino puede ser una consola, un archivo u otro elemento, según el appender.
nivel	El nivel es necesario para controlar el filtrado de los mensajes de registro.
límite	El appender puede tener un nivel de umbral asociado independientemente del nivel del registrador. El Appender ignora cualquier mensaje de registro que tenga un nivel inferior al nivel de umbral.
filtrar	Los objetos de filtro pueden analizar la información de registro más allá de la coincidencia de nivel y decidir si las solicitudes de registro deben ser manejadas por un Appender particular o ignoradas.

Podemos agregar un objeto Appender a un registrador al incluir la siguiente configuración en el archivo de configuración con el siguiente método:

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

Puede escribir la misma configuración en formato XML de la siguiente manera:

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

Si está dispuesto a agregar un objeto Appender dentro de su programa, puede usar el siguiente método:

public void addAppender(Appender appender);

El método addAppender () agrega un Appender al objeto Logger. Como demuestra la configuración de ejemplo, es posible agregar muchos objetos Appender a un registrador en una lista separada por comas, cada uno imprimiendo información de registro en destinos separados.

Hemos utilizado solo un appender FileAppender en nuestro ejemplo anterior. Todas las posibles opciones de adición son:

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

Cubriremos FileAppender en el registro en archivos y JDBC Appender se trataría en el registro en la base de datos .

Diseño

Hemos utilizado PatternLayout con nuestro appender. Todas las opciones posibles son:

DateLayout
HTMLLayout
PatternLayout
SimpleLayout
XMLLayout

Con HTMLLayout y XMLLayout, puede generar registros en HTML y también en formato XML.

Formato de diseño

Aprenderá a formatear un mensaje de registro en el capítulo: Formato de registro .

Hemos visto cómo crear un archivo de configuración. Este capítulo describe cómo generar mensajes de depuración y registrarlos en un archivo de texto simple.

A continuación se muestra un archivo de configuración simple creado para nuestro ejemplo. Revisémoslo una vez más:

El nivel del registrador raíz se define como DEBUG y le adjunta un appender llamado FILE.
El archivo adjunto se define como org.apache.log4j.FileAppender y escribe en un archivo llamado "log.out" ubicado en el log directorio.
El patrón de diseño definido es% m% n, lo que significa que el mensaje de registro impreso será seguido por un carácter de nueva línea.

El contenido del archivo log4j.properties es el siguiente:

# 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

Usando log4j en el programa Java

La siguiente clase de Java es un ejemplo muy simple que inicializa y luego usa la biblioteca de registro Log4J para aplicaciones 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");
   }
}

Compilar y ejecutar

Estos son los pasos para compilar y ejecutar el programa mencionado anteriormente. Asegúrate de haber configuradoPATH y CLASSPATH apropiadamente antes de proceder a la compilación y ejecución.

Todas las bibliotecas deben estar disponibles en CLASSPATHy su archivo log4j.properties debería estar disponible en PATH. Siga los pasos que se indican a continuación:

Cree log4j.properties como se muestra arriba.
Cree log4jExample.java como se muestra arriba y compílelo.
Ejecute log4jExample binary para ejecutar el programa.

Obtendría el siguiente resultado dentro del archivo /usr/home/log4j/log.out:

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

La clase Logger proporciona una variedad de métodos para manejar las actividades de registro. La clase Logger no nos permite crear una nueva instancia de Logger, pero proporciona dos métodos estáticos para obtener un objeto Logger:

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

El primero de los dos métodos devuelve el registrador raíz de la instancia de la aplicación y no tiene nombre.

Cualquier otra instancia de objeto Logger con nombre se obtiene a través del segundo método pasando el nombre del registrador. El nombre del registrador puede ser cualquier cadena que pueda pasar, generalmente una clase o un nombre de paquete como lo hemos usado en el último capítulo y se menciona a continuación:

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

Métodos de registro

Una vez que obtenemos una instancia de un registrador con nombre, podemos usar varios métodos del registrador para registrar mensajes. La clase Logger tiene los siguientes métodos para imprimir la información de registro.

No Señor	Métodos y descripción
1	public void debug(Object message) Imprime mensajes con el nivel Level.DEBUG.
2	public void error(Object message) Imprime mensajes con el nivel Level.ERROR.
3	public void fatal(Object message); Imprime mensajes con el nivel Level.FATAL.
4	public void info(Object message); Imprime mensajes con el nivel Level.INFO.
5	public void warn(Object message); Imprime mensajes con el nivel Level.WARN.
6	public void trace(Object message); Imprime mensajes con el nivel Level.TRACE.

Todos los niveles se definen en la clase org.apache.log4j.Level y cualquiera de los métodos mencionados anteriormente se puede llamar de la siguiente manera:

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!");
   }
}

Cuando compila y ejecuta el programa LogClass, generará el siguiente resultado:

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

Todos los mensajes de depuración tienen más sentido cuando se utilizan en combinación con niveles. Cubriremos los niveles en el próximo capítulo y luego, tendrá una buena comprensión de cómo usar estos métodos en combinación con diferentes niveles de depuración.

La clase org.apache.log4j.Level proporciona los siguientes niveles. También puede definir sus niveles personalizados subclasificando la clase Nivel.

Nivel	Descripción
TODAS	Todos los niveles, incluidos los niveles personalizados.
DEPURAR	Designa eventos informativos detallados que son más útiles para depurar una aplicación.
INFO	Designa mensajes informativos que destacan el progreso de la aplicación a un nivel más detallado.
ADVERTIR	Designa situaciones potencialmente dañinas.
ERROR	Designa eventos de error que aún pueden permitir que la aplicación continúe ejecutándose.
FATAL	Designa eventos de error muy graves que presumiblemente harán que la aplicación se anule.
APAGADO	El rango más alto posible y está destinado a desactivar el registro.
RASTRO	Designa eventos informativos más detallados que el DEBUG.

¿Cómo funcionan los niveles?

Una solicitud de registro de nivel p en un registrador con nivel qestá habilitado si p> = q. Esta regla está en el corazón de log4j. Asume que los niveles están ordenados. Para los niveles estándar, tenemos TODOS <DEBUG <INFO <WARN <ERROR <FATAL <OFF.

El siguiente ejemplo muestra cómo podemos filtrar todos nuestros mensajes DEBUG e INFO. Este programa utiliza el método de registro setLevel (Level.X) para establecer un nivel de registro deseado:

Este ejemplo imprimiría todos los mensajes excepto 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!");
   }
}

Cuando compila y ejecuta el programa LogClass, generará el siguiente resultado:

Warn Message!
Error Message!
Fatal Message!

Establecer niveles mediante el archivo de configuración

log4j le proporciona una configuración de nivel basada en archivos de configuración que lo libera de cambiar el código fuente cuando desea cambiar el nivel de depuración.

A continuación se muestra un archivo de configuración de ejemplo que realizaría la misma tarea que hicimos con el método log.setLevel (Level.WARN) en el ejemplo anterior.

# 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

Usemos ahora nuestro siguiente programa:

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!");
   }
}

Ahora compile y ejecute el programa anterior y obtendrá el siguiente resultado en el archivo /usr/home/log4j/log.out:

Warn Message!
Error Message!
Fatal Message!

Apache log4j proporciona varios objetos de diseño, cada uno de los cuales puede formatear los datos de registro de acuerdo con varios diseños. También es posible crear un objeto Diseño que formatee los datos de registro de una manera específica de la aplicación.

Todos los objetos Layout reciben un objeto LoggingEvent de los objetos Appender. Los objetos Layout luego recuperan el argumento del mensaje del LoggingEvent y aplican el ObjectRenderer apropiado para obtener la representación de cadena del mensaje.

Los tipos de diseño

La clase de nivel superior en la jerarquía es la clase abstracta org.apache.log4j.Layout. Esta es la clase base para todas las demás clases de diseño en la API log4j.

La clase Layout se define como abstracta dentro de una aplicación, nunca usamos esta clase directamente; en cambio, trabajamos con sus subclases que son las siguientes:

DateLayout
HTMLLayout
PatternLayout.
SimpleLayout
XMLLayout

Los métodos de diseño

Esta clase proporciona una implementación esquemática de todas las operaciones comunes en todos los demás objetos Layout y declara dos métodos abstractos.

No Señor.	Métodos y descripción
1	public abstract boolean ignoresThrowable() Indica si la información de registro maneja algún objeto java.lang.Throwable que se le haya pasado como parte del evento de registro. Si el objeto Layout maneja el objeto Throwable, entonces el objeto Layout no lo ignora y devuelve falso.
2	public abstract String format(LoggingEvent event) Las subclases de diseño individuales implementan este método para el formato específico del diseño.

Aparte de estos métodos abstractos, la clase Layout proporciona una implementación concreta para los métodos que se enumeran a continuación:

No Señor.	Métodos y descripción
1	public String getContentType() Devuelve el tipo de contenido utilizado por los objetos Layout. La clase base devuelve texto / sin formato como tipo de contenido predeterminado.
2	public String getFooter() Especifica la información de pie de página del mensaje de registro.
3	public String getHeader() Especifica la información del encabezado del mensaje de registro.

Cada subclase puede devolver información específica de la clase anulando la implementación concreta de estos métodos.

Para escribir su información de registro en un archivo, tendría que usar org.apache.log4j.FileAppender .

Configuración de FileAppender

FileAppender tiene los siguientes parámetros configurables:

Propiedad	Descripción
InmediatoFlush	Este indicador se establece de forma predeterminada en verdadero, lo que significa que el flujo de salida del archivo se vacía con cada operación de adición.
codificacion	Es posible utilizar cualquier codificación de caracteres. De forma predeterminada, es el esquema de codificación específico de la plataforma.
límite	El nivel de umbral para este appender.
Nombre del archivo	El nombre del archivo de registro.
fileAppend	Esto se establece de forma predeterminada en verdadero, lo que significa que la información de registro se agrega al final del mismo archivo.
bufferIO	Esta bandera indica si necesitamos la escritura en búfer habilitada. De forma predeterminada, se establece en falso.
tamaño del búfer	Si la E / S almacenada en búfer está habilitada, indica el tamaño del búfer. De forma predeterminada, está configurado en 8 kb.

A continuación se muestra un archivo de configuración de muestra log4j.properties para 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

Si desea tener un archivo de configuración XML equivalente al archivo log4j.properties anterior , aquí está el contenido:

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

Puede probar log4j - Programa de muestra con la configuración anterior.

Iniciar sesión en varios archivos

Es posible que desee escribir sus mensajes de registro en varios archivos por ciertas razones, por ejemplo, si el tamaño del archivo alcanzó un cierto umbral.

Para escribir su información de registro en varios archivos, tendría que usar la clase org.apache.log4j.RollingFileAppender que extiende la clase FileAppender y hereda todas sus propiedades.

Tenemos los siguientes parámetros configurables además de los mencionados anteriormente para FileAppender:

Propiedad	Descripción
Tamaño máximo de archivo	Este es el tamaño crítico del archivo por encima del cual se desplazará el archivo. El valor predeterminado es 10 MB.
maxBackupIndex	Esta propiedad denota la cantidad de archivos de respaldo que se crearán. El valor predeterminado es 1.

A continuación se muestra un archivo de configuración de muestra log4j.properties para 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

Si desea tener un archivo de configuración XML, puede generar el mismo que se menciona en la sección inicial y agregar solo parámetros adicionales relacionados con RollingFileAppender .

Esta configuración de ejemplo demuestra que el tamaño máximo permitido de cada archivo de registro es de 5 MB. Al exceder el tamaño máximo, se creará un nuevo archivo de registro. Dado que maxBackupIndex se define como 2, una vez que el segundo archivo de registro alcanza el tamaño máximo, el primer archivo de registro se borrará y, a partir de entonces, toda la información de registro se revertirá al primer archivo de registro.

Puede probar log4j - Programa de muestra con la configuración anterior.

Generación diaria de archivos de registro

Puede ser necesario generar sus archivos de registro a diario para mantener un registro limpio de su información de registro.

Para escribir su información de registro en archivos a diario, tendría que usar la clase org.apache.log4j.DailyRollingFileAppender que extiende la clase FileAppender y hereda todas sus propiedades.

Solo hay un parámetro configurable importante además de los mencionados anteriormente para FileAppender:

Propiedad	Descripción
DatePattern	Esto indica cuándo pasar el archivo y la convención de nomenclatura que se debe seguir. De forma predeterminada, la renovación se realiza a la medianoche todos los días.

DatePattern controla la programación de rollover mediante uno de los siguientes patrones:

DatePattern	Descripción
'.' aaaa-MM	Pasa al final de cada mes y al comienzo del mes siguiente.
'.' aaaa-MM-dd	Dé la vuelta a la medianoche todos los días. Este es el valor predeterminado.
'.' aaaa-MM-dd-a	Dé la vuelta al mediodía y a la medianoche de cada día.
'.' aaaa-MM-dd-HH	Da la vuelta al principio de cada hora.
'.' aaaa-MM-dd-HH-mm	Pasa cada minuto.
'.' aaaa-ww	Pase la vuelta el primer día de cada semana, según el lugar.

A continuación, se muestra un archivo de configuración de muestra log4j.properties para generar archivos de registro que se transfieren al mediodía y a la medianoche de cada día.

# 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

Si desea tener un archivo de configuración XML, puede generar el mismo que se menciona en la sección inicial y agregar solo parámetros adicionales relacionados con DailyRollingFileAppender .

Puede probar log4j - Programa de muestra con la configuración anterior.

La API log4j proporciona el objeto org.apache.log4j.jdbc.JDBCAppender , que puede colocar información de registro en una base de datos específica.

Configuración de JDBCAppender

Propiedad	Descripción
tamaño del búfer	Establece el tamaño del búfer. El tamaño predeterminado es 1.
conductor	Establece la clase de controlador en la cadena especificada. Si no se especifica ninguna clase de controlador, el valor predeterminado es sun.jdbc.odbc.JdbcOdbcDriver.
diseño	Establece el diseño que se utilizará. El diseño predeterminado es org.apache.log4j.PatternLayout.
contraseña	Establece la contraseña de la base de datos.
sql	Especifica la instrucción SQL que se ejecutará cada vez que se produzca un evento de registro. Esto podría ser INSERT, UPDATE o DELETE.
URL	Establece la URL de JDBC.
usuario	Establece el nombre de usuario de la base de datos.

Configuración de la tabla de registro

Antes de comenzar a utilizar el registro basado en JDBC, debe crear una tabla para mantener toda la información del registro. A continuación se muestra la instrucción SQL para crear la tabla 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
   );

Archivo de configuración de muestra

A continuación se muestra un archivo de configuración de muestra log4j.properties para JDBCAppender que se utilizará para registrar mensajes en una tabla de 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

Para la base de datos MySQL, tendría que usar el DBNAME, el ID de usuario y la contraseña reales, donde ha creado la tabla de LOGS. La instrucción SQL es ejecutar una instrucción INSERT con el nombre de tabla LOGS y los valores que se ingresarán en la tabla.

JDBCAppender no necesita que se defina explícitamente un diseño. En su lugar, la instrucción SQL que se le pasa utiliza un PatternLayout.

Si desea tener un archivo de configuración XML equivalente al archivo log4j.properties anterior , aquí está el contenido:

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

Programa de muestra

La siguiente clase de Java es un ejemplo muy simple que se inicializa y luego usa la biblioteca de registro Log4J para aplicaciones 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");
   }
}

Compilar y ejecutar

Estos son los pasos para compilar y ejecutar el programa mencionado anteriormente. Asegúrate de haber configuradoPATH y CLASSPATH apropiadamente antes de proceder a la compilación y ejecución.

Todas las bibliotecas deben estar disponibles en CLASSPATHy su archivo log4j.properties debería estar disponible en PATH. Siga los pasos dados:

Cree log4j.properties como se muestra arriba.
Cree log4jExample.java como se muestra arriba y compílelo.
Ejecute log4jExample binary para ejecutar el programa.

Ahora verifique su tabla de LOGS dentro de la base de datos DBNAME y encontrará las siguientes entradas:

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:Aquí x se utiliza para generar el contexto de diagnóstico anidado (NDC) asociado con el hilo que generó el evento de registro. Usamos NDC para distinguir clientes en componentes del lado del servidor que manejan múltiples clientes. Consulte el manual de Log4J para obtener más información al respecto.

↰ Previous page