Logger em Java – Exemplo de Registro Java

Tutoriais

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

Logger em Java

API de Logging em Java 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 as características básicas do Java Logger. Também veremos um exemplo de Logger em Java com diferentes níveis de logging, Manipuladores de Logging, Formatos, Filtros, Gerenciador de Logs e configurações de logging.

Java Logger

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 apenas uma linha de código muito simples como;

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

Níveis de Logging em Java

A classe java.util.logging.Level define os diferentes níveis de log do Java. Existem sete níveis de logging no Java.

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

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

logger.setLevel(Level.FINE);

Os logs serão gerados para todos os níveis iguais ou maiores que o nível do logger. Por exemplo, se o nível do logger for definido como INFO, os logs serão gerados para mensagens de logging INFO, WARNING e SEVERE.

Manipuladores de Logging do Java

Podemos adicionar vários manipuladores a um logger do Java e sempre que registrarmos uma mensagem, cada manipulador a processará conforme necessário. Existem dois manipuladores padrão fornecidos pela API de Logging do Java.

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

Podemos criar nossos próprios manipuladores personalizados também para executar 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 registro Java personalizado:

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 do 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 formatador 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 formato personalizado estendendo a classe java.util.logging.Formatter e anexá-la a qualquer um dos manipuladores. Aqui está um exemplo de uma classe de formatador personalizado 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 Logs do Java

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

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

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

handlers= java.util.logging.ConsoleHandler

.level= FINE

# A saída padrão do arquivo está no diretório inicial 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

# Limite 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 manipulador personalizado
        logger.addHandler(new MyHandler());
        try {
            // Nome do arquivo FileHandler com limite de tamanho máximo e número de limites de arquivos de log
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            // Configurando 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();
        }
    }

}

Quando você executar o programa de exemplo de logger Java acima, 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 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 de formatação 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 no 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 final de exemplo do Logger Java. Isso é tudo para Logger em Java e Exemplo de Logger Java. Você pode baixar o projeto no link abaixo.

Baixar Projeto Exemplo de Logger em Java

Referência: API de Logging do Java

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