Logger en Java – Ejemplo de Registro en Java

Tutoriales

Hoy vamos a analizar Logger en Java. Java Logger proporciona registro en la programación java.

Logger en Java

Java Logging API fue introducido en la versión 1.4 y puedes usar la API de registro de Java para registrar mensajes de aplicación. En este tutorial de registro de Java, aprenderemos las características básicas de Java Logger. También veremos un ejemplo de Java Logger de diferentes niveles de registro, Manipuladores de Registro, Formateadores, Filtros, Administrador de Registros y configuraciones de registro.

Java Logger

java.util.logging.Logger es la clase utilizada para registrar mensajes de aplicación en la API de registro de Java. Podemos crear un Logger de Java con una línea de código muy simple como;

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

Niveles de Registro de Java

java.util.logging.Level define los diferentes niveles de registro de Java. Hay siete niveles de registro en Java.

  1. SEVERE (el más alto)
  2. WARNING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Existen otros dos niveles de registro, OFF que desactivará todo el registro y ALL que registrará todos los mensajes. Podemos establecer el nivel del registro usando el siguiente código:

logger.setLevel(Level.FINE);

Los registros se generarán para todos los niveles iguales o mayores que el nivel del registro. Por ejemplo, si el nivel del registro se establece en INFO, se generarán registros para los mensajes de registro de INFO, WARNING y SEVERE.

Controladores de Registro de Java

Podemos agregar múltiples controladores a un registro de Java y cada vez que registramos algún mensaje, cada controlador lo procesará en consecuencia. Hay dos controladores predeterminados proporcionados por la API de Registro de Java.

  1. ConsoleHandler: Este controlador escribe todos los mensajes de registro en la consola
  2. FileHandler: Este controlador escribe todos los mensajes de registro en un archivo en formato XML.

Podemos crear nuestros propios controladores personalizados también para realizar tareas específicas. Para crear nuestra propia clase Handler, necesitamos extender la clase java.util.logging.Handler o cualquiera de sus subclases como StreamHandler, SocketHandler, etc. Aquí hay un ejemplo de un controlador 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) {
        //agregar lógica propia para publicar
        super.publish(record);
    }


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


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

}

Formateadores de registro Java

Los formateadores se utilizan para dar formato a los mensajes de registro. Hay dos formateadores disponibles en la API de registro de Java.

  1. SimpleFormatter: Este formateador genera mensajes de texto con información básica. ConsoleHandler utiliza esta clase de formateador para imprimir mensajes de registro en la consola.
  2. XMLFormatter: Este formateador genera un mensaje XML para el registro, FileHandler utiliza XMLFormatter como formateador predeterminado.

Podemos crear nuestra propia clase de formateador personalizado extendiendo la clase java.util.logging.Formatter y adjuntándola a cualquiera de los controladores. Aquí hay un ejemplo de una clase de formateador personalizado simple.

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";
    }

}

Registro en Java – Java Log Manager

java.util.logging.LogManager es la clase que lee la configuración de registro, crea y mantiene las instancias del registro. Podemos usar esta clase para configurar nuestra propia configuración específica de la aplicación.

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

Aquí hay un ejemplo de archivo de configuración de la API de registro de Java. Si no especificamos ninguna configuración, se lee desde el archivo lib/logging.properties de JRE Home.mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# la salida de archivo predeterminada está en el directorio principal del usuario.
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 los mensajes que se imprimen en la consola a INFO y superiores.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Aquí hay un programa Java simple que muestra el uso de Logger en 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());
        //agregando manejador personalizado
        logger.addHandler(new MyHandler());
        try {
            //Nombre del archivo FileHandler con tamaño máximo y límite de número de archivos de registro
            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++){
                //mensajes de registro
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Cuando ejecutes el programa de ejemplo de registro de Java anterior, notarás que el registro CONFIG no se imprime en el archivo, eso es debido a la clase 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) {
		//no registrar registros CONFIG en el archivo
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

También el formato de salida será el mismo que el definido por la clase 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

Si no agregamos nuestra propia clase Formatter a FileHandler, el mensaje de registro se imprimirá así.

<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>

Los mensajes de registro en la consola tendrán el siguiente 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

La siguiente imagen muestra el proyecto de ejemplo final del registro de Java.Eso es todo para Logger en Java y el Ejemplo de Logger en Java. Puedes descargar el proyecto desde el siguiente enlace.

Descargar Proyecto de Ejemplo de Java Logger

Referencia: API de Registro de Java

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