log4j - Guia rápido

log4j é uma estrutura de registro (APIs) confiável, rápida e flexível escrita em Java, que é distribuída sob a licença de software Apache.

log4j foi portado para as linguagens C, C ++, C #, Perl, Python, Ruby e Eiffel.

log4j é altamente configurável por meio de arquivos de configuração externos em tempo de execução. Ele vê o processo de registro em termos de níveis de prioridade e oferece mecanismos para direcionar as informações de registro para uma grande variedade de destinos, como banco de dados, arquivo, console, UNIX Syslog, etc.

log4j tem três componentes principais:

loggers: Responsável por capturar informações de registro.
appenders: Responsável por publicar informações de registro em vários destinos preferenciais.
layouts: Responsável por formatar informações de registro em diferentes estilos.

História do log4j

Iniciado no início de 1996 como API de rastreamento para o projeto EU SEMPER (Secure Electronic Marketplace for Europe).
Após incontáveis aprimoramentos e várias encarnações, a API inicial evoluiu para se tornar log4j, um pacote de registro popular para Java.
O pacote é distribuído sob a Licença de Software Apache, uma licença de código aberto completa certificada pela iniciativa de código aberto.
A versão mais recente do log4j, incluindo seu código-fonte completo, arquivos de classe e documentação pode ser encontrada em http://logging.apache.org/log4j/.

Recursos log4j

É thread-safe.
Ele é otimizado para velocidade.
É baseado em uma hierarquia de logger nomeada.
Ele suporta vários appenders de saída por logger.
Suporta internacionalização.
Não se restringe a um conjunto predefinido de instalações.
O comportamento de registro pode ser definido em tempo de execução usando um arquivo de configuração.
Ele é projetado para lidar com exceções Java desde o início.
Ele usa vários níveis, ou seja, ALL, TRACE, DEBUG, INFO, WARN, ERROR e FATAL.
O formato da saída do log pode ser facilmente alterado estendendo a classe Layout .
O destino da saída do log, bem como a estratégia de gravação, podem ser alterados por implementações da interface do Appender.
É uma parada de falha. No entanto, embora certamente se esforce para garantir a entrega, log4j não garante que cada instrução de log será entregue ao seu destino.

Prós e contras do registro

O registro é um componente importante do desenvolvimento de software. Um código de registro bem escrito oferece depuração rápida, fácil manutenção e armazenamento estruturado das informações de tempo de execução de um aplicativo.

Log também tem suas desvantagens. Isso pode tornar um aplicativo lento. Se muito prolixo, pode causar cegueira de rolagem. Para aliviar essas preocupações, o log4j foi projetado para ser confiável, rápido e extensível.

Como o registro raramente é o foco principal de um aplicativo, a API log4j se esforça para ser simples de entender e usar.

O pacote de API log4j é distribuído sob a Apache Software License, uma licença de código aberto completa certificada pela iniciativa de código aberto.

A versão mais recente do log4j, incluindo código-fonte completo, arquivos de classe e documentação pode ser encontrada em http://logging.apache.org/log4j/.

Para instalar o log4j em seu sistema, baixe apache-log4j-xxxtar.gz do URL especificado e siga as etapas abaixo.

Passo 1

Descompacte e descompacte o arquivo baixado no diretório / usr / local / da seguinte maneira:

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

Ao descompactar, ele criaria uma hierarquia de diretório com um nome apache-log4j-xxx como 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

Esta etapa é opcional e depende de quais recursos você usará da estrutura log4j. Se você já tem os seguintes pacotes instalados em sua máquina, tudo bem, caso contrário, você precisa instalá-los para fazer o log4j funcionar.

JavaMail API:O recurso de registro baseado em e-mail no log4j requer que o Java Mail API (mail.jar) seja instalado em sua máquina a partir de glassfish.dev .
JavaBeans Activation Framework: A API do Java Mail também exigirá que o JavaBeans Activation Framework (activation.jar) seja instalado em sua máquina a partir de http://java.sun.com/products/javabeans/jaf/index.jsp.
Java Message Service: Os recursos compatíveis com JMS de log4j exigirão que JMS e Java Naming e Directory Interface JNDI sejam instalados em sua máquina a partir de http://java.sun.com/products/jms.
XML Parser:Você precisa de um analisador XML compatível com JAXP para usar o log4j. Certifique-se de ter o Xerces.jar instalado em sua máquina a partir dehttp://xerces.apache.org/xerces-j/install.html.

etapa 3

Agora você precisa configurar o CLASSPATH e PATHvariáveis apropriadamente. Aqui, vamos configurá-lo apenas para o arquivo 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/

A API log4j segue uma arquitetura em camadas onde cada camada fornece objetos diferentes para executar tarefas diferentes. Essa arquitetura em camadas torna o design flexível e fácil de estender no futuro.

Existem dois tipos de objetos disponíveis com a estrutura log4j.

Core Objects:Esses são objetos obrigatórios do framework. Eles são obrigados a usar a estrutura.
Support Objects:Esses são objetos opcionais da estrutura. Eles oferecem suporte a objetos centrais para realizar tarefas adicionais, mas importantes.

Objetos Centrais

Os objetos principais incluem os seguintes tipos de objetos:

Objeto Logger

A camada de nível superior é o Logger, que fornece o objeto Logger. O objeto Logger é responsável por capturar as informações de log e elas são armazenadas em uma hierarquia de namespace.

Objeto de Layout

A camada de layout fornece objetos que são usados para formatar informações de registro em diferentes estilos. Ele fornece suporte para objetos anexadores antes de publicar informações de registro.

Objetos de layout desempenham um papel importante na publicação de informações de registro de uma forma que seja legível e reutilizável.

Objeto Appender

Esta é uma camada de nível inferior que fornece objetos Appender. O objeto Appender é responsável por publicar informações de registro em vários destinos preferenciais, como banco de dados, arquivo, console, UNIX Syslog, etc.

O diagrama virtual a seguir mostra os componentes de uma estrutura log4J:

Objetos de Suporte

Existem outros objetos importantes na estrutura log4j que desempenham um papel vital na estrutura de registro:

Objeto de Nível

O objeto Level define a granularidade e a prioridade de qualquer informação de registro. Existem sete níveis de registro definidos na API: OFF, DEBUG, INFO, ERROR, WARN, FATAL e ALL.

Objeto de Filtro

O objeto Filtro é usado para analisar as informações de registro e tomar outras decisões sobre se essas informações devem ser registradas ou não.

Um objeto Appender pode ter vários objetos Filtro associados a ele. Se as informações de registro forem passadas para um determinado objeto Appender, todos os objetos Filtro associados a esse Appender precisam aprovar as informações de registro antes que possam ser publicadas no destino anexado.

ObjectRenderer

O objeto ObjectRenderer é especializado em fornecer uma representação de String de diferentes objetos passados para a estrutura de registro. Este objeto é usado por objetos Layout para preparar as informações finais de registro.

LogManager

O objeto LogManager gerencia a estrutura de registro. Ele é responsável por ler os parâmetros de configuração iniciais de um arquivo de configuração de todo o sistema ou de uma classe de configuração.

O capítulo anterior explicou os componentes principais do log4j. Este capítulo explica como você pode configurar os componentes principais usando um arquivo de configuração. Configurar log4j envolve atribuir o Nível, definir o Appender e especificar objetos de Layout em um arquivo de configuração.

O arquivo log4j.properties é um arquivo de configuração log4j que mantém propriedades em pares chave-valor. Por padrão, o LogManager procura um arquivo denominado log4j.properties noCLASSPATH.

O nível do logger raiz é definido como DEBUG. O DEBUG anexa o appender denominado X a ele.
Defina o anexador denominado X para ser um anexador válido.
Defina o layout do anexador X.

Sintaxe log4j.properties:

A seguir está a sintaxe do arquivo log4j.properties para um 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 Exemplo

Usando a sintaxe acima, definimos o seguinte no arquivo log4j.properties :

O nível do logger root é definido como DEBUG, o appender DEBUG chamado FILE para ele.
O anexador FILE é definido como org.apache.log4j.FileAppender . Ele grava em um arquivo chamado "log.out" localizado nolog diretório.
O padrão de layout definido é % m% n , o que significa que a mensagem de registro impressa será seguida por um caractere de nova linha.

# 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 observar que log4j suporta substituição de variável no estilo UNIX, como $ {variableName}.

Nível de depuração

Usamos DEBUG com ambos os appenders. Todas as opções possíveis são:

TRACE
DEBUG
INFO
WARN
ERROR
FATAL
ALL

Esses níveis seriam explicados em Níveis de registro log4j .

Anexos

Apache log4j fornece objetos Appender que são os principais responsáveis por imprimir mensagens de log para destinos diferentes, como consoles, arquivos, sockets, logs de eventos NT, etc.

Cada objeto Appender possui propriedades diferentes associadas a ele, e essas propriedades indicam o comportamento desse objeto.

Propriedade	Descrição
layout	O Appender usa os objetos Layout e o padrão de conversão associado a eles para formatar as informações de registro.
alvo	O destino pode ser um console, um arquivo ou outro item, dependendo do anexador.
nível	O nível é necessário para controlar a filtragem das mensagens de log.
limite	O Appender pode ter um nível de limite associado a ele independente do nível do registrador. O Appender ignora quaisquer mensagens de log que tenham um nível inferior ao nível de limite.
filtro	Os objetos de filtro podem analisar informações de log além da correspondência de nível e decidir se as solicitações de log devem ser tratadas por um Appender específico ou ignoradas.

Podemos adicionar um objeto Appender a um Logger incluindo a seguinte configuração no arquivo de configuração com o seguinte método:

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

Você pode escrever a mesma configuração no formato XML da seguinte maneira:

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

Se você deseja adicionar o objeto Appender dentro de seu programa, pode usar o seguinte método:

public void addAppender(Appender appender);

O método addAppender () adiciona um Appender ao objeto Logger. Como a configuração de exemplo demonstra, é possível adicionar muitos objetos Appender a um registrador em uma lista separada por vírgulas, cada um imprimindo informações de registro para destinos separados.

Usamos apenas um appender FileAppender em nosso exemplo acima. Todas as opções de appender possíveis são:

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

Cobriríamos FileAppender em Logging in Files e JDBC Appender seria abordado em Logging in Database .

Layout

Usamos PatternLayout com nosso appender. Todas as opções possíveis são:

DateLayout
HTMLLayout
PatternLayout
SimpleLayout
XMLLayout

Usando HTMLLayout e XMLLayout, você pode gerar log em HTML e também em formato XML.

Formatação de Layout

Você aprenderia como formatar uma mensagem de registro no capítulo: Formatação de registro .

Vimos como criar um arquivo de configuração. Este capítulo descreve como gerar mensagens de depuração e registrá-las em um arquivo de texto simples.

A seguir está um arquivo de configuração simples criado para nosso exemplo. Vamos revisar mais uma vez:

O nível do logger raiz é definido como DEBUG e anexa um anexo denominado FILE a ele.
O anexador FILE é definido como org.apache.log4j.FileAppender e grava em um arquivo chamado "log.out" localizado no log diretório.
O padrão de layout definido é% m% n, o que significa que a mensagem de registro impressa será seguida por um caractere de nova linha.

O conteúdo do arquivo log4j.properties é o seguinte:

# 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 no programa Java

A seguinte classe Java é um exemplo muito simples que inicializa e, em seguida, usa a biblioteca de registro Log4J para aplicativos 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 e executar

Aqui estão as etapas para compilar e executar o programa mencionado acima. Certifique-se de ter definidoPATH e CLASSPATH apropriadamente antes de proceder à compilação e execução.

Todas as bibliotecas devem estar disponíveis em CLASSPATHe seu arquivo log4j.properties deve estar disponível em PATH. Siga as etapas abaixo:

Crie log4j.properties conforme mostrado acima.
Crie log4jExample.java conforme mostrado acima e compile-o.
Execute log4jExample binário para executar o programa.

Você obteria o seguinte resultado dentro do arquivo /usr/home/log4j/log.out:

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

A classe Logger fornece uma variedade de métodos para lidar com atividades de log. A classe Logger não nos permite instanciar uma nova instância Logger, mas fornece dois métodos estáticos para obter um objeto Logger:

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

O primeiro dos dois métodos retorna o criador de logs raiz da instância do aplicativo e não tem um nome.

Qualquer outra instância do objeto Logger nomeado é obtida por meio do segundo método, passando o nome do logger. O nome do logger pode ser qualquer string que você pode passar, geralmente uma classe ou um nome de pacote como usamos no último capítulo e é mencionado abaixo:

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

Métodos de registro

Depois de obter uma instância de um logger nomeado, podemos usar vários métodos do logger para registrar mensagens. A classe Logger possui os seguintes métodos para imprimir as informações de registro.

Sr. Não	Métodos e Descrição
1	public void debug(Object message) Ele imprime mensagens com o nível Level.DEBUG.
2	public void error(Object message) Imprime mensagens com o nível Level.ERROR.
3	public void fatal(Object message); Imprime mensagens com o nível Level.FATAL.
4	public void info(Object message); Ele imprime mensagens com o nível Level.INFO.
5	public void warn(Object message); Ele imprime mensagens com o nível Level.WARN.
6	public void trace(Object message); Ele imprime mensagens com o nível Level.TRACE.

Todos os níveis são definidos na classe org.apache.log4j.Level e qualquer um dos métodos mencionados acima pode ser chamado da seguinte maneira:

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 você compila e executa o programa LogClass, ele gera o seguinte resultado:

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

Todas as mensagens de depuração fazem mais sentido quando são usadas em combinação com níveis. Cobriremos os níveis no próximo capítulo e, em seguida, você terá um bom entendimento de como usar esses métodos em combinação com diferentes níveis de depuração.

A classe org.apache.log4j.Level fornece os seguintes níveis. Você também pode definir seus níveis personalizados classificando a classe Level.

Nível	Descrição
TODOS	Todos os níveis, incluindo níveis personalizados.
DEPURAR	Designa eventos informativos refinados que são mais úteis para depurar um aplicativo.
INFO	Designa mensagens informativas que destacam o progresso do aplicativo em nível de granulação grossa.
ADVERTIR	Designa situações potencialmente prejudiciais.
ERRO	Designa eventos de erro que ainda podem permitir que o aplicativo continue em execução.
FATAL	Designa eventos de erro muito graves que provavelmente levarão o aplicativo ao aborto.
FORA	A classificação mais alta possível e destina-se a desligar o registro.
VESTÍGIO	Designa eventos informativos mais detalhados do que DEBUG.

Como funcionam os níveis?

Uma solicitação de log de nível p em um logger com nível qé habilitado se p> = q. Essa regra está no cerne do log4j. Ele assume que os níveis estão ordenados. Para os níveis padrão, temos ALL <DEBUG <INFO <WARN <ERROR <FATAL <OFF.

O exemplo a seguir mostra como podemos filtrar todas as nossas mensagens DEBUG e INFO. Este programa usa o método setLevel (Level.X) do logger para definir um nível de log desejado:

Este exemplo imprimiria todas as mensagens, exceto 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 você compila e executa o programa LogClass, ele gera o seguinte resultado:

Warn Message!
Error Message!
Fatal Message!

Definir níveis usando arquivo de configuração

log4j fornece a você a definição de nível com base no arquivo de configuração que o liberta de alterar o código-fonte quando quiser alterar o nível de depuração.

A seguir está um arquivo de configuração de exemplo que executaria a mesma tarefa que fizemos usando o método log.setLevel (Level.WARN) no exemplo acima.

# 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

Vamos agora usar nosso seguinte 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!");
   }
}

Agora compile e execute o programa acima e você obteria o seguinte resultado no arquivo /usr/home/log4j/log.out:

Warn Message!
Error Message!
Fatal Message!

Apache log4j fornece vários objetos Layout, cada um dos quais pode formatar dados de registro de acordo com vários layouts. Também é possível criar um objeto Layout que formata os dados de registro de uma forma específica do aplicativo.

Todos os objetos Layout recebem um objeto LoggingEvent dos objetos Appender. Os objetos Layout, então, recuperam o argumento da mensagem do LoggingEvent e aplicam o ObjectRenderer apropriado para obter a representação String da mensagem.

Os Tipos de Layout

A classe de nível superior na hierarquia é a classe abstrata org.apache.log4j.Layout. Esta é a classe base para todas as outras classes de Layout na API log4j.

A classe Layout é definida como abstrata em um aplicativo, nunca usamos essa classe diretamente; em vez disso, trabalhamos com suas subclasses, que são as seguintes:

DateLayout
HTMLLayout
PatternLayout.
SimpleLayout
XMLLayout

Os Métodos de Layout

Esta classe fornece uma implementação de esqueleto de todas as operações comuns em todos os outros objetos Layout e declara dois métodos abstratos.

Sr. Não.	Métodos e Descrição
1	public abstract boolean ignoresThrowable() Indica se as informações de registro tratam de qualquer objeto java.lang.Throwable transmitido a ele como parte do evento de registro. Se o objeto Layout manipular o objeto Throwable, o objeto Layout não o ignorará e retornará falso.
2	public abstract String format(LoggingEvent event) Subclasses de layout individuais implementam este método para formatação específica de layout.

Além desses métodos abstratos, a classe Layout fornece implementação concreta para os métodos listados abaixo:

Sr. Não.	Métodos e Descrição
1	public String getContentType() Ele retorna o tipo de conteúdo usado pelos objetos Layout. A classe base retorna text / plain como o tipo de conteúdo padrão.
2	public String getFooter() Ele especifica as informações do rodapé da mensagem de registro.
3	public String getHeader() Ele especifica as informações do cabeçalho da mensagem de registro.

Cada subclasse pode retornar informações específicas da classe, substituindo a implementação concreta desses métodos.

Para gravar suas informações de registro em um arquivo, você teria que usar org.apache.log4j.FileAppender .

Configuração de FileAppender

FileAppender tem os seguintes parâmetros configuráveis:

Propriedade	Descrição
InstantFlush	Esse sinalizador é definido por padrão como verdadeiro, o que significa que o fluxo de saída para o arquivo é liberado com cada operação de acréscimo.
codificação	É possível usar qualquer codificação de caracteres. Por padrão, é o esquema de codificação específico da plataforma.
limite	O nível de limite para este anexador.
Nome do arquivo	O nome do arquivo de log.
fileAppend	Por padrão, é definido como verdadeiro, o que significa que as informações de registro estão sendo anexadas ao final do mesmo arquivo.
bufferedIO	Este sinalizador indica se precisamos habilitar a gravação em buffer. Por padrão, é definido como falso.
tamanho do buffer	Se a E / S com buffer estiver habilitada, indica o tamanho do buffer. Por padrão, é definido como 8kb.

A seguir está um arquivo de configuração de amostra 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

Se você deseja ter um arquivo de configuração XML equivalente ao arquivo log4j.properties acima , aqui está o conteúdo:

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

Você pode tentar log4j - Programa de amostra com a configuração acima.

Login em vários arquivos

Você pode querer gravar suas mensagens de log em vários arquivos por certos motivos, por exemplo, se o tamanho do arquivo atingiu um determinado limite.

Para gravar suas informações de registro em vários arquivos, você teria que usar a classe org.apache.log4j.RollingFileAppender, que estende a classe FileAppender e herda todas as suas propriedades.

Temos os seguintes parâmetros configuráveis, além dos mencionados acima para FileAppender:

Propriedade	Descrição
maxFileSize	Este é o tamanho crítico do arquivo acima do qual o arquivo será rolado. O valor padrão é 10 MB.
maxBackupIndex	Esta propriedade denota o número de arquivos de backup a serem criados. O valor padrão é 1.

A seguir está um arquivo de configuração de amostra 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

Se você deseja ter um arquivo de configuração XML, pode gerar o mesmo mencionado na seção inicial e adicionar apenas parâmetros adicionais relacionados a RollingFileAppender .

Este exemplo de configuração demonstra que o tamanho máximo permitido de cada arquivo de log é 5 MB. Ao exceder o tamanho máximo, um novo arquivo de log será criado. Como maxBackupIndex é definido como 2, quando o segundo arquivo de log atinge o tamanho máximo, o primeiro arquivo de log será apagado e, a partir daí, todas as informações de log serão revertidas para o primeiro arquivo de log.

Você pode tentar log4j - Programa de amostra com a configuração acima.

Geração de arquivo de log diário

Pode ser necessário gerar seus arquivos de log diariamente para manter um registro limpo de suas informações de log.

Para gravar suas informações de registro em arquivos diariamente, você teria que usar a classe org.apache.log4j.DailyRollingFileAppender, que estende a classe FileAppender e herda todas as suas propriedades.

Há apenas um parâmetro configurável importante além dos mencionados acima para FileAppender:

Propriedade	Descrição
DatePattern	Isso indica quando rolar o arquivo e a convenção de nomenclatura a ser seguida. Por padrão, a rolagem é realizada à meia-noite de cada dia.

DatePattern controla a programação de rollover usando um dos seguintes padrões:

DatePattern	Descrição
'.' aaaa-MM	Role no final de cada mês e no início do mês seguinte.
'.' aaaa-MM-dd	Role à meia-noite todos os dias. Este é o valor padrão.
'.' aaaa-MM-dd-a	Role ao meio-dia e meia-noite de cada dia.
'.' aaaa-MM-dd-HH	Role no início de cada hora.
'.' aaaa-MM-dd-HH-mm	Role a cada minuto.
'.' yyyy-ww	Passe o mouse no primeiro dia de cada semana, dependendo do local.

A seguir está um arquivo de configuração de amostra log4j.properties para gerar arquivos de log ao meio-dia e meia-noite de cada dia.

# 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 você deseja ter um arquivo de configuração XML, pode gerar o mesmo mencionado na seção inicial e adicionar apenas parâmetros adicionais relacionados ao DailyRollingFileAppender .

Você pode tentar log4j - Programa de amostra com a configuração acima.

A API log4j fornece o objeto org.apache.log4j.jdbc.JDBCAppender , que pode colocar informações de registro em um banco de dados especificado.

Configuração JDBCAppender

Propriedade	Descrição
tamanho do buffer	Define o tamanho do buffer. O tamanho padrão é 1.
motorista	Define a classe do driver para a string especificada. Se nenhuma classe de driver for especificada, o padrão é sun.jdbc.odbc.JdbcOdbcDriver.
layout	Define o layout a ser usado. O layout padrão é org.apache.log4j.PatternLayout.
senha	Define a senha do banco de dados.
sql	Especifica a instrução SQL a ser executada sempre que ocorre um evento de registro. Pode ser INSERT, UPDATE ou DELETE.
URL	Define o URL JDBC.
do utilizador	Define o nome de usuário do banco de dados.

Configuração da Tabela de Log

Antes de começar a usar o log baseado em JDBC, você deve criar uma tabela para manter todas as informações de log. A seguir está a instrução SQL para criar a tabela 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
   );

Arquivo de configuração de amostra

A seguir está um arquivo de configuração de amostra log4j.properties para JDBCAppender que será usado para registrar mensagens em uma tabela 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 o banco de dados MySQL, você teria que usar o DBNAME real, ID do usuário e senha, onde você criou a tabela LOGS. A instrução SQL é para executar uma instrução INSERT com o nome da tabela LOGS e os valores a serem inseridos na tabela.

JDBCAppender não precisa que um layout seja definido explicitamente. Em vez disso, a instrução SQL passada para ele usa um PatternLayout.

Se você deseja ter um arquivo de configuração XML equivalente ao arquivo log4j.properties acima , aqui está o conteúdo:

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

A seguinte classe Java é um exemplo muito simples que inicializa e, em seguida, usa a biblioteca de registro Log4J para aplicativos 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 e executar

Aqui estão as etapas para compilar e executar o programa mencionado acima. Certifique-se de ter definidoPATH e CLASSPATH apropriadamente antes de prosseguir para a compilação e execução.

Todas as bibliotecas devem estar disponíveis em CLASSPATHe seu arquivo log4j.properties deve estar disponível em PATH. Siga as etapas fornecidas:

Crie log4j.properties conforme mostrado acima.
Crie log4jExample.java conforme mostrado acima e compile-o.
Execute log4jExample binário para executar o programa.

Agora verifique sua tabela LOGS dentro do banco de dados DBNAME e você encontrará as seguintes 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:Aqui, x é usado para gerar o Contexto de diagnóstico aninhado (NDC) associado ao encadeamento que gerou o evento de registro. Usamos NDC para distinguir clientes em componentes do lado do servidor que lidam com vários clientes. Verifique o Manual Log4J para obter mais informações sobre isso.