Introdução:

Existe uma maneira mais robusta de obter informações sobre o fluxo de

execução de nosso programa sem recorrer a debugs ou sysouts: utilizar uma
API de Logging. Boas APIs nos permitem ativar/desativar sem alterar código,
pode ser persistido em algum lugar (arquivos, BD etc) e ainda podemos
controlar o nível de informações que queremos ver (desde bem detalhadas a
ver apenas os erros que acontecem).
O 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 é um pacote
de registro popular escrito em Java. O log4j foi portado para os idiomas C, C +
+, C #, Perl, Python, Ruby e Eiffel.
O log4j é altamente configurável através de arquivos de configuração externos
no tempo de execução. Ele visualiza o processo de registro em termos de
níveis de prioridades e oferece mecanismos para direcionar informações de
registro para uma grande variedade de destinos, como um banco de dados,
arquivo, console, UNIX Syslog, etc.
O Log4j é uma ferramenta muito poderosa para depuração da sua aplicação.
Grandes projetos não deixar isso passar em branco, pois este é essencial para
saber o que de fato sua aplicação está fazendo sem precisar ficar depurando
com a própria IDE.

História do log4j:
 Começou no início de 1996 como API de rastreamento para o projeto
EU SEMPER (Secure Electronic Marketplace for Europe).
 Depois de inúmeras melhorias e várias encarnações, a API inicial
evoluiu para se tornar log4j, um pacote de registro popular para Java.
 Foi originalmente escrito por Ceki Gülcü e faz parte do projeto Apache
Logging Services da Apache Software Foundation. Log4j é um dos
vários frameworks de logging 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.

log4j tem três componentes principais:

  Loggers: Responsável por capturar informações de registro.
 Appenders: Responsável pela publicação de informações de registro
em vários destinos preferidos.
 Layouts: Responsável pela formatação de informações de registro em
diferentes estilos.

Recursos do log4j

1 - Maior confiabilidade. As mensagens não são perdidas durante a

reconfiguração da estrutura, como no Log4j 1 ou Logback

2 - Extensibilidade: O Log4j 2 suporta um sistema de plugins para permitir que

os usuários definam e configurem componentes personalizados

3 - Sintaxe de configuração simplificada

4 - Suporte para configurações xml, json, yaml e properties

5 - Filtros melhorados

6 - Suporte de pesquisa de propriedades para valores definidos no arquivo de

configuração, nas propriedades do sistema, nas variáveis de ambiente, no
Mapa ThreadContext e nos dados presentes no evento

7 - Suporte para várias APIs: O Log4j 2 pode ser usado com aplicativos que
usam as APIs Log4j 2, Log4j 1.2, SLF4J, o Commons Logging e
java.util.logging (JUL).

8 - Níveis de registro personalizados

9 - Suporte a lambda no estilo Java 8 para "registro lento"

10 - Marcadores

11 - Suporte para objetos Message definidos pelo usuário

12 - "Livre de lixo ou lixo baixo" em configurações comuns

Velocidade aprimorada

Prós e contras do registro em log:

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

Logging tem suas desvantagens também. Pode retardar um aplicativo. Se for

muito detalhado, pode causar cegueira rolante. Para aliviar essas
preocupações, o log4j é projetado para ser confiável, rápido e extensível.

Como a criação de log raramente é o foco principal de um aplicativo, a API

log4j se esforça para ser simples de entender e usar.

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

Para instalar o log4j no seu sistema, faça o download do apache-log4j-

xxxtar.gz da URL especificada e siga os passos 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/
.......................................

Enquanto untarring, criaria uma hierarquia de diretório com um nome apache-

log4j-xxx da seguinte forma:

-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á a partir do
framework log4j. Se você já tem os seguintes pacotes instalados em sua
máquina, então está tudo bem, caso contrário você precisa instalá-los para
fazer o log4j funcionar.

 API JavaMail: O recurso de registro baseado em e-mail no log4j requer

que a API do Java Mail (mail.jar) seja instalada em sua máquina a partir
do glassfish.dev .

 JavaBeans Activation Framework: O Java Mail API 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 .

 Serviço de Mensagens Java: Os recursos compatíveis com JMS do

log4j exigirão que o JNDI do JMS e do Java Naming e do Directory
Interface sejam instalados em sua máquina a partir
de http://java.sun.com/products/jms .

 Analisador XML: 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 em http://xerces.apache.org/xerces-j/install.html .

Etapa 3
Agora você precisa configurar as variáveis CLASSPATH e PATH
apropriadamente. Aqui vamos defini-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/

Arquitetura:
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 o framework log4j.

 Objetos principais: são objetos obrigatórios do framework. Eles são

obrigados a usar o framework.
 Objetos de suporte: são objetos opcionais da estrutura. Eles suportam
objetos centrais para executar tarefas adicionais, mas importantes.

Objetos principais:
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 registro 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 a objetos
anexadores antes de publicar informações de log.

Objetos de layout desempenham um papel importante na publicação de

informações de registro de uma maneira que seja legível e reutilizável.

Objeto do Appender
Essa é uma camada de nível inferior que fornece objetos do Appender. O
objeto appender é responsável por publicar informações de log para vários
destinos preferenciais, como banco de dados, arquivo, console, Syslog UNIX
etc.
Objetos de suporte:
Existem outros objetos importantes no framework log4j que desempenham um
papel vital na estrutura de logging:

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

Objeto de filter
O objeto Filter é 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 Filter associados a eles. Se as

informações de registro forem transmitidas para um objeto do Anexador em
particular, todos os objetos de Filtro associados a esse Anexador precisarão
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 criação de log. Esse
objeto é usado pelos objetos Layout para preparar as informações finais de
criação de log.

LogManager
O objeto LogManager gerencia a estrutura de registro. Ele é responsável por
ler os parâmetros de configuração inicial de um arquivo de configuração do
sistema ou de uma classe de configuração.
O diagrama a seguir mostra os componentes de uma estrutura log4J

Configuração:
Configurar log4j envolve designar o Level, definir Appender e especificar
objetos Layout em um arquivo de configuração.

O arquivo log4j.properties é um arquivo de configuração log4j. Por padrão, o

LogManager procura por um arquivo
chamado log4j.properties no CLASSPATH.

 O nível do criador de logs raiz é definido como DEBUG. O DEBUG

anexa o appender chamando-o X.

 Defina o appender chamado X como um appender válido.

 Defina o layout para o appender X.

log4j.properties Sintaxe:

A seguir, 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 criador de logs raiz é definido como DEBUG,

o anexador DEBUG denominado FILE.

 O appender FILE é definido como org.apache.log4j.FileAppender. Ele

grava em um arquivo chamado log.out, localizado no diretório de log.

 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
Appenders
O Apache log4j fornece objetos do Appender que são os principais
responsáveis pela impressão de mensagens de log para destinos diferentes,
como consoles, arquivos, soquetes, logs de eventos do NT, etc.

Cada objeto do Appender possui propriedades diferentes associadas a ele e

essas propriedades indicam o comportamento desse objeto.

Nome Descrição

Layout O anexador usa os objetos Layout e o padrão de conversão

associado a eles para formatar as informações de registro.

Target O destino pode ser um console, um arquivo ou outro item,

dependendo do anexador.

Level O nível é necessário para controlar a filtragem das

mensagens de log.

Threshold O appender pode ter um nível de limite associado a ele

independente do nível do registrador. O Appender ignora
todas as mensagens de log que tenham um nível inferior ao
nível do threshold.

Filter Os objetos Filter podem analisar informações de log além da

correspondência de níveis e decidir se as solicitações de log
devem ser manipuladas por um determinado Appender ou
ignoradas.

Layout
Usamos o 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 no

formato XML também.

Como gerar mensagens de depuração e registrá-las em um arquivo de texto

simples.

Usando log4j no programa Java

A seguinte classe Java é um exemplo muito simples que inicializa e, em
seguida, usa a biblioteca de criação de log 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");

}
Compile e execute
Aqui estão os passos para compilar e executar o programa acima
mencionado. Certifique-se de ter
definido PATH e CLASSPATH adequadamente antes de prosseguir para a
compilação e execução.

Todas as bibliotecas devem estar disponíveis em CLASSPATH e

seu arquivo log4j.properties deve estar disponível no PATH . Siga os passos
abaixo -

 Crie log4j.properties como mostrado acima.

 Crie log4jExample.java como mostrado acima e compile-o.
 Execute o binário log4jExample 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

Logging Methods
A classe Logger fornece uma variedade de métodos para lidar com atividades
de registro. A classe Logger não permite instanciar uma nova instância do
Agente de Log, 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 possui um nome.

Qualquer outra instância do objeto Logger nomeado é obtida através do

segundo método, passando o nome do logger. O nome do logger pode ser
qualquer string que você possa 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());

Assim que obtivermos uma instância de um agente de log 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.

Métodos e Descrição

1 public debug void (Mensagem de Objeto)

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 (Mensagem de Objeto)

Imprime mensagens com o nível Level.FATAL.

4 public void info (Mensagem de Objeto)

Imprime mensagens com o nível Level.INFO.

5 public void warn (Mensagem de Objeto)

Imprime mensagens com o nível Level.WARN.

6 public void trace (Object message)

Imprime mensagens com o nível Level.TRACE.

Logging Levels

Nível Descrição

ALL Todos os níveis, incluindo níveis personalizados.

DEBUG Designa eventos informativos refinados que são mais úteis

 para depurar um aplicativo.

INFO Designa mensagens informativas que destacam o progresso

do aplicativo no nível de granulação grossa.

WARN Designa situações potencialmente prejudiciais.

ERROR Designa eventos de erro que ainda podem permitir que o

aplicativo continue em execução.

FATAL Designa eventos de erro muito graves que presumivelmente

levarão o aplicativo a ser anulado.

OFF A classificação mais alta possível e destina-se a desativar o

log.

TRACE Designa eventos informativos mais detalhados do que o

DEBUG.

Como funcionam os níveis?

Uma solicitação de log do nível p em um registrador com nível q é ativada se
p> = q. Esta regra é o coração do log4j. Assume que os níveis sã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 logger setLevel (Level.X) para
definir um nível de registro 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ê compilar e executar o programa LogClass, ele geraria o

seguinte resultado -
Warn Message!
Error Message!
Fatal Message!

Definindo níveis usando o arquivo de configuração

log4j fornece configuração de nível baseado em arquivo de configuração que o
liberta de alterar o código-fonte quando você deseja alterar o nível de
depuração.

A seguir está um exemplo de arquivo de configuração que executaria a

mesma tarefa que usamos 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 o nosso programa a seguir -

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!

Formatação de Log
O 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 maneira
específica do aplicativo.

Todos os objetos Layout recebem um objeto LoggingEvent dos objetos

do Appender . Os objetos Layout, em seguida, recuperam o argumento de
mensagem do LoggingEvent e aplicam o ObjectRenderer apropriado para
obter a representação de 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 dentro de uma aplicação, 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
Essa classe fornece uma implementação esquelética de todas as operações
comuns em todos os outros objetos Layout e declara dois métodos abstratos.

Métodos e Descrição

1 public abstract boolean ignoresThrowable()

Indica se as informações de registro manipulam qualquer objeto

java.lang.Throwable passado para ele como parte do evento de
registro. Se o objeto Layout manipular o objeto Throwable, o objeto
Layout não o ignorará e retornará false.
2 public abstract String format(LoggingEvent event)
Subclasses de layout individuais implementam esse método para
formatação específica do layout.

Além desses métodos abstratos, a classe Layout fornece implementação

concreta para os métodos listados abaixo:

Sr. Métodos e Descrição

Nã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 ()

Especifica as informações do rodapé da mensagem de log.

3 public String getHeader ()

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.