Neste tutorial, aprenderemos sobre o Java Logging e seus vários componentes com a ajuda de exemplos.
Java nos permite criar e capturar mensagens de log e arquivos por meio do processo de log.
Em Java, o registro requer estruturas e APIs. Java possui uma estrutura de registro integrada no java.util.loggingpacote.
Também podemos usar estruturas de terceiros como Log4j, Logback e muitos mais para fins de registro.
Componentes de registro Java
A figura abaixo representa os componentes principais e o fluxo de controle da API Java Logging ( java.util.logging).
Java Logging
1. Logger
A Loggerclasse fornece métodos para registro. Podemos instanciar objetos da Loggerclasse e chamar seus métodos para fins de registro.
Vamos dar um exemplo.
Logger logger = Logger.getLogger("newLoggerName");
O getLogger()método da Loggerclasse é usado para encontrar ou criar um novo Logger. O argumento string define o nome do logger.
Aqui, isso cria um novo Loggerobjeto ou retorna um existente Loggercom o mesmo nome.
É uma convenção definir um Loggerapós a classe atual usando class.getName().
Logger logger = Logger.getLogger(MyClass.class.getName());
Nota: Este método irá lançar NullPointerExceptionse o nome passado for null.
Cada Loggerum possui um nível que determina a importância da mensagem de log. Existem 7 níveis básicos de registro:
| Nível de registro (em ordem decrescente) | Usar |
|---|---|
| FORTE | falha grave |
| ATENÇÃO | mensagem de aviso, um problema potencial |
| INFO | informações gerais de tempo de execução |
| CONFIG | informação de configuração |
| BEM | informações gerais do desenvolvedor (mensagens de rastreamento) |
| FINER | informações detalhadas do desenvolvedor (mensagens de rastreamento) |
| FINEST | informações altamente detalhadas do desenvolvedor (mensagens de rastreamento) |
| FORA | desligue o registro para todos os níveis (não capture nada) |
| TODOS | ligue o registro para todos os níveis (capture tudo) |
Cada nível de log possui um valor inteiro que determina sua gravidade, exceto para dois níveis de log especiais OFFe ALL.
Registrando a mensagem
Por padrão, os três níveis de log principais 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 FINEe os níveis acima dele são definidos 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 nos níveis desejados.
logger.info( "This is INFO log level message"); logger.warning( "This is WARNING log level message");
Todas as solicitações de log que passaram do nível de log definido são então encaminhadas para o LogRecord .
Observação: se o nível de um logger for definido como null, seu nível será herdado de seu pai e assim por diante na árvore.
2. Filtros
Um filtro (se houver) 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 LogRecord só é passado do criador de logs 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 (Anexos)
O manipulador de log ou os appenders recebem o LogRecord e o exportam para vários destinos.
Java SE fornece 5 gerenciadores integrados:
| Handlers | Usar |
|---|---|
StreamHandler | escreve para um OutputStream |
ConsoleHandler | escreve para o console |
FileHandler | grava no arquivo |
SocketHandler | grava em portas TCP remotas |
MemoryHandler | escreve na memória |
Um manipulador pode passar o LogRecord para 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 logger 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 objeto LogRecord em uma string antes de exportá-lo para sistemas externos.
Java SE tem dois formatadores integrados :
| Formatadores | Usar |
|---|---|
SimpleFormatter | formata LogRecord para string |
XMLFormatter | formata LogRecord em formato 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 objeto LogManager controla as informações de registro global. Ele lê e mantém a configuração de registro 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 de registro
Aqui estão algumas das vantagens do registro em Java.
- ajuda no monitoramento do fluxo do programa
- ajuda a capturar quaisquer erros que possam ocorrer
- fornece suporte para diagnóstico de problemas e depuração
