Journalisateur en Java – Exemple de Journalisation en Java

Tutoriels

Aujourd’hui, nous examinerons le Logger en Java. Java Logger fournit le journalisation dans la programmation Java.

Logger en Java

L’API de journalisation Java a été introduite en 1.4 et vous pouvez utiliser l’API de journalisation Java pour journaliser les messages d’application. Dans ce tutoriel de journalisation Java, nous apprendrons les fonctionnalités de base du Logger Java. Nous examinerons également un exemple de Logger Java avec différents niveaux de journalisation, des Gestionnaires de journalisation, des Formateurs, des Filtres, un Gestionnaire de journaux et des configurations de journalisation.

Logger Java

java.util.logging.Logger est la classe utilisée pour journaliser les messages d’application dans l’API de journalisation Java. Nous pouvons créer un Logger Java avec une ligne de code très simple comme suit :

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

Niveaux de journalisation Java

La classe java.util.logging.Level définit les différents niveaux de journalisation en Java. Il existe sept niveaux de journalisation en Java.

  1. SEVERE (le plus élevé)
  2. WARNING
  3. INFO
  4. CONFIG
  5. FINE
  6. FINER
  7. FINEST

Il existe deux autres niveaux de journalisation, OFF qui désactive tout le journal et ALL qui journalise tous les messages. Nous pouvons définir le niveau de journalisation du journaliseur en utilisant le code suivant:

logger.setLevel(Level.FINE);

Les journaux seront générés pour tous les niveaux supérieurs ou égaux au niveau du journaliseur. Par exemple, si le niveau du journaliseur est défini sur INFO, les journaux seront générés pour les messages de journalisation INFO, WARNING et SEVERE.

Gestionnaires de journalisation Java

Nous pouvons ajouter plusieurs gestionnaires à un journaliseur Java et chaque gestionnaire traitera les messages en conséquence. Deux gestionnaires par défaut sont fournis par l’API de journalisation Java.

  1. ConsoleHandler: Ce gestionnaire écrit tous les messages de journalisation sur la console
  2. FileHandler: Ce gestionnaire écrit tous les messages de journalisation dans un fichier au format XML.

Nous pouvons également créer nos propres gestionnaires personnalisés pour effectuer des tâches spécifiques. Pour créer notre propre classe Handler, nous devons étendre la classe java.util.logging.Handler ou l’une de ses sous-classes comme StreamHandler, SocketHandler, etc. Voici un exemple d’un gestionnaire de journalisation Java personnalisé :

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) {
        //ajouter sa propre logique pour publier
        super.publish(record);
    }


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


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

}

Formateurs de journalisation Java

Les formateurs sont utilisés pour formater les messages de journal. Il existe deux formateurs disponibles dans l’API de journalisation Java.

  1. SimpleFormatter: Ce formateur génère des messages textuels avec des informations de base. ConsoleHandler utilise cette classe de formateur pour imprimer les messages de journal sur la console.
  2. XMLFormatter: Ce formateur génère un message XML pour le journal, FileHandler utilise XMLFormatter comme formateur par défaut.

Nous pouvons créer notre propre classe de formateur personnalisé en étendant la classe java.util.logging.Formatter et la rattacher à l’un des gestionnaires. Voici un exemple d’une classe de formateur personnalisée 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";
    }

}

Logger en Java – Gestionnaire de journaux Java

La classe java.util.logging.LogManager est celle qui lit la configuration de journalisation, crée et maintient les instances de logger. Nous pouvons utiliser cette classe pour définir notre propre configuration spécifique à l’application.

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

Voici un exemple de fichier de configuration de l’API de journalisation Java. Si nous ne spécifions aucune configuration, elle est lue à partir du fichier lib/logging.properties du répertoire JRE.mylogging.properties

handlers= java.util.logging.ConsoleHandler

.level= FINE

# La sortie par défaut est dans le répertoire personnel de l'utilisateur.
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

# Limiter les messages imprimés sur la console à INFO et supérieur.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

com.journaldev.files = SEVERE

Voici un programme Java simple montrant l’utilisation 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());
        // Ajout d'un gestionnaire personnalisé
        logger.addHandler(new MyHandler());
        try {
            // Nom du fichier FileHandler avec une taille maximale et une limite de nombre de fichiers journaux
            Handler fileHandler = new FileHandler("/Users/pankaj/tmp/logger.log", 2000, 5);
            fileHandler.setFormatter(new MyFormatter());
            // Configuration du filtre personnalisé pour FileHandler
            fileHandler.setFilter(new MyFilter());
            logger.addHandler(fileHandler);
            
            for(int i=0; i<1000; i++){
                // Messages de journalisation
                logger.log(Level.INFO, "Msg"+i);
            }
            logger.log(Level.CONFIG, "Config data");
        } catch (SecurityException | IOException e) {
            e.printStackTrace();
        }
    }

}

Lorsque vous exécutez le programme d’exemple de journal Java ci-dessus, vous remarquerez que le journal CONFIG n’est pas imprimé dans le fichier, c’est à cause de la 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) {
		// Ne pas enregistrer les journaux CONFIG dans le fichier
		if(log.getLevel() == Level.CONFIG) return false;
		return true;
	}

}

De plus, le format de sortie sera le même que celui défini par la 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

Si nous n’ajoutons pas notre propre classe Formatter à FileHandler, le message de journal sera imprimé comme ceci.

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

Les messages de journal de la console seront au format suivant:

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

L’image ci-dessous montre le projet d’exemple final du journal Java. C’est tout pour Logger en Java et l’exemple de journal Java. Vous pouvez télécharger le projet depuis le lien ci-dessous.

Téléchargez le projet d’exemple de Java Logger

Référence: API de journalisation Java

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