Java Logging
Java Logging
Neste tutorial, aprenderemos sobre o Java Logging e seus vários componentes com a ajuda de exemplos.
Java nos permite criar e capturar mensagens e arquivos de log por meio do processo de log.
Em Java, o log requer frameworks e APIs. Java tem uma estrutura de registro embutida no java.util.logging pacote.
Também podemos usar estruturas de terceiros como Log4j, Logback e muito mais para fins de registro.
Componentes de Log de Java
A figura abaixo representa os componentes principais e o fluxo de controle da API Java Logging (
java.util.logging ). 
1. Registrador
O
Logger classe fornece métodos para log. Podemos instanciar objetos do Logger class e chame seus métodos para fins de registro. Vamos dar um exemplo.
Logger logger = Logger.getLogger("newLoggerName");
O
getLogger() método do Logger classe é usada para encontrar ou criar um novo Logger . O argumento string define o nome do registrador. Aqui, isso cria um novo
Logger objeto ou retorna um Logger existente com o mesmo nome. É uma convenção para definir um
Logger após a classe atual usando class.getName() .
Logger logger = Logger.getLogger(MyClass.class.getName());
Observação: Este método lançará
NullPointerException se o nome passado for null . Cada
Logger tem um nível que determina a importância da mensagem de log. Existem 7 níveis básicos de log:| Nível de registro (em ordem decrescente) | Usar |
|---|---|
| GRAVE | falha grave |
| AVISO | mensagem de aviso, um possível problema |
| INFORMAÇÕES | informações gerais de tempo de execução |
| CONFIGURAÇÃO | informações de configuração |
| BEM | informações gerais do desenvolvedor (mensagens de rastreamento) |
| MAIS | informações detalhadas do desenvolvedor (mensagens de rastreamento) |
| O MELHOR | informações do desenvolvedor altamente detalhadas (mensagens de rastreamento) |
| DESATIVADO | desative o registro para todos os níveis (não capture nada) |
| TODOS | ative o registro para todos os níveis (capture tudo) |
Cada nível de log tem um valor inteiro que determina sua gravidade, exceto por dois níveis de log especiais
OFF e ALL . Registrando a mensagem
Por padrão, os três principais níveis de log são sempre registrados. Para definir um nível diferente, podemos usar o seguinte código:
logger.setLevel(Level.LogLevel);
// example
logger.setLevel(Level.FINE);
Neste exemplo, apenas o nível
FINE e os níveis acima dele são configurados para serem registrados. Todas as outras mensagens de log são descartadas. Agora para registrar uma mensagem, usamos o
log() método.
logger.log(Level.LogLevel, "log message");
// example
logger.log(Level.INFO, "This is INFO log level message");
Existem métodos abreviados para registrar em níveis desejados.
logger.info( "This is INFO log level message");
logger.warning( "This is WARNING log level message");
Todas as solicitações de registro que passaram no nível de registro definido são encaminhadas para o LogRecord .
Observação: Se o nível de um registrador estiver definido como
null , seu nível é herdado de seu pai e assim por diante na árvore. 2. Filtros
Um filtro (se estiver presente) determina se o LogRecord deve ser encaminhado ou não. Como o nome sugere, ele filtra as mensagens de log de acordo com critérios específicos.
Um Registro de Log só é passado do registrador para o manipulador de log e do manipulador de log para sistemas externos se passar nos critérios especificados.
// set a filter
logger.setFilter(filter);
// get a filter
Filter filter = logger.getFilter();
3. Manipuladores (Anexadores)
O manipulador de log ou os anexadores recebem o LogRecord e exporta para vários destinos.
O Java SE fornece 5 manipuladores integrados:
| Manipuladores | Usar |
|---|---|
StreamHandler | grava em um OutputStream |
ConsoleHandler | grava no console |
FileHandler | grava no arquivo |
SocketHandler | grava em portas TCP remotas |
MemoryHandler | grava na memória |
Um manipulador pode passar o LogRecord a um filtro para determinar novamente se ele pode ser encaminhado para sistemas externos ou não.
Para adicionar um novo manipulador, usamos o seguinte código:
logger.addHandler(handler);
// example
Handler handler = new ConsoleHandler();
logger.addHandler(handler);
Para remover um manipulador, usamos o seguinte código:
logger.removeHandler(handler);
// example
Handler handler = new ConsoleHandler();
logger.addHandler(handler);
logger.removeHandler(handler);
Um registrador pode ter vários manipuladores. Para obter todos os manipuladores, usamos o seguinte código:
Handler[] handlers = logger.getHandlers();
4. Formatadores
Um manipulador também pode usar um Formatter para formatar o LogRecord objeto em uma string antes de exportá-lo para sistemas externos.
Java SE tem dois Formatters integrados :
| Formatadores | Usar |
|---|---|
SimpleFormatter | formatos Registro de log para encadear |
XMLFormatter | formatos Registro de log para formulário XML |
Podemos usar o seguinte código para formatar um manipulador:
// formats to string form
handler.setFormatter(new SimpleFormatter());
// formats to XML form
handler.setFormatter(new XMLFormatter());
LogManager
O LogManager objeto mantém o controle das informações globais de log. Ele lê e mantém a configuração de log e as instâncias do registrador.
O gerenciador de log é um singleton, o que significa que apenas uma instância dele é instanciada.
Para obter a instância do gerenciador de log, usamos o seguinte código:
LogManager manager = new LogManager();
Vantagens do Logging
Aqui estão algumas das vantagens de fazer login em Java.
- ajuda no monitoramento do fluxo do programa
- ajuda a capturar quaisquer erros que possam ocorrer
- fornece suporte para diagnóstico e depuração de problemas
Java