Logger em Java – Exemplo de Log em Java

Tutoriais

Hoje vamos analisar o Logger em Java. O Logger em Java fornece registro em programação Java.

Logger em Java

Java Logging API foi introduzida na versão 1.4 e você pode usar a API de logging em Java para registrar mensagens de aplicativo. Neste tutorial de logging em Java, aprenderemos os recursos básicos do Logger em Java. Também examinaremos um exemplo de Logger em Java de diferentes níveis de logging, Manipuladores de Logging, Formatares, Filtros, Gerenciador de Logs e configurações de logging.

Logger em Java

java.util.logging.Logger é a classe usada para registrar mensagens de aplicativo na API de logging em Java. Podemos criar um Logger em Java com um código muito simples de uma linha como;

Logger logger = Logger.getLogger(MyClass.class.getName());

Níveis de Logging em Java

java.util.logging.Level define os diferentes níveis de registro do Java. Existem sete níveis de registro em Java.

  1. SEVERE (mais alto)
  2. WARNING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Há outros dois níveis de registro, OFF que desativará todo o registro e ALL que registrará todas as mensagens. Podemos definir o nível do registrador usando o seguinte código:

logger.setLevel(Level.FINE);

Os registros serão gerados para todos os níveis iguais ou maiores que o nível do registrador. Por exemplo, se o nível do registrador estiver definido como INFO, os registros serão gerados para mensagens de registro INFO, WARNING e SEVERE.

Manipuladores de Registros do Java

Podemos adicionar vários manipuladores a um registrador Java e sempre que registrarmos qualquer mensagem, cada manipulador a processará adequadamente. Existem dois manipuladores padrão fornecidos pela API de Registro do Java.

  1. ConsoleHandler: Este manipulador escreve todas as mensagens de registro no console
  2. FileHandler: Este manipulador escreve todas as mensagens de registro em um arquivo no formato XML.

Podemos criar nossos próprios manipuladores personalizados também para realizar tarefas específicas. Para criar nossa própria classe Handler, precisamos estender a classe java.util.logging.Handler ou qualquer uma de suas subclasses como StreamHandler, SocketHandler etc. Aqui está um exemplo de um manipulador de log personalizado em Java:

package com.journaldev.log;

import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;

public class MyHandler extends StreamHandler {

    @Override
    public void publish(LogRecord record) {
        //adicionar lógica própria para publicar
        super.publish(record);
    }


    @Override
    public void flush() {
        super.flush();
    }


    @Override
    public void close() throws SecurityException {
        super.close();
    }

}

Formatadores de Log em Java

Os formatadores são usados para formatar as mensagens de log. Existem dois formatadores disponíveis na API de logging do Java.

  1. SimpleFormatter: Este formatador gera mensagens de texto com informações básicas. ConsoleHandler usa esta classe de formatação para imprimir mensagens de log no console.
  2. XMLFormatter: Este formatador gera mensagem XML para o log, FileHandler usa XMLFormatter como um formatador padrão.

Podemos criar nossa própria classe de Formatação personalizada estendendo a classe java.util.logging.Formatter e anexá-la a qualquer um dos manipuladores. Aqui está um exemplo de uma classe de formatação personalizada simples.

package com.journaldev.log;

import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;

public class MyFormatter extends Formatter {

    @Override
    public String format(LogRecord record) {
        return record.getThreadID()+"::"+record.getSourceClassName()+"::"
                +record.getSourceMethodName()+"::"
                +new Date(record.getMillis())+"::"
                +record.getMessage()+"\n";
    }

}

Logger em Java – Gerenciador de Log Java

A classe java.util.logging.LogManager é responsável por ler a configuração de registro, criar e manter as instâncias do logger. Podemos usar esta classe para definir nossa própria configuração específica de aplicativo.

LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));

Aqui está um exemplo de arquivo de configuração da API de registro do Java. Se não especificarmos nenhuma configuração, ela será lida do arquivo lib/logging.properties na pasta principal do JRE. mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# a saída de arquivo padrão está no diretório principal do usuário.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Limitar as mensagens que são impressas no console para INFO e acima.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Aqui está um programa Java simples mostrando o uso do Logger em Java.

package com.journaldev.log;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.logging.ConsoleHandler;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

public class LoggingExample {

    static Logger logger = Logger.getLogger(LoggingExample.class.getName());
    
    public static void main(String[] args) {
        try {
            LogManager.getLogManager().readConfiguration(new FileInputStream("mylogging.properties"));
        } catch (SecurityException | IOException e1) {
            e1.printStackTrace();
        }
        logger.setLevel(Level.FINE);
        logger.addHandler(new ConsoleHandler());
        //adicionando um manipulador personalizado
        logger.addHandler(new MyHandler());
        try {
            //Nome do arquivo FileHandler com tamanho máximo e limite de número de arquivos de log
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            //definindo filtro personalizado para FileHandler
            fileHandler.setFilter(new MyFilter());
            logger.addHandler(fileHandler);
            
            for(int i=0; i<1000; i++){
                //mensagens de registro
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Ao executar o programa de exemplo de logger Java acima, você notará que o log CONFIG não está sendo impresso no arquivo, isso ocorre por causa da classe MyFilter.

package com.journaldev.log;

import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;

public class MyFilter implements Filter {

	@Override
	public boolean isLoggable(LogRecord log) {
		//não registrar logs CONFIG no arquivo
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

Também o formato de saída será o mesmo que o definido pela classe MyFormatter.

1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg977
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg978
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg979
1::com.journaldev.log.LoggingExample::main::Sat Dec 15 01:42:43 PST 2012::Msg980

Se não adicionarmos nossa própria classe Formatter ao FileHandler, a mensagem de log será impressa assim.

<record>
  <date>2012-12-14T17:03:13</date>
  <millis>1355533393319</millis>
  <sequence>996</sequence>
  <logger>com.journaldev.log.LoggingExample</logger>
  <level>INFO</level>
  <class>com.journaldev.log.LoggingExample</class>
  <method>main</method>
  <thread>1</thread>
  <message>Msg996</message>
</record>

As mensagens de log do console serão no seguinte formato:

Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg997
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998
Dec 15, 2012 1:42:43 AM com.journaldev.log.LoggingExample main
INFO: Msg998

A imagem abaixo mostra o projeto de exemplo final do Logger Java. Isso é tudo para o Logger em Java e Exemplo de Logger Java. Você pode baixar o projeto pelo link abaixo.

Baixar Projeto de Exemplo do Java Logger

Referência: API de Registro do Java

Source:
https://www.digitalocean.com/community/tutorials/logger-in-java-logging-example