La journalisation ou la notion de “log” est un procédé qui recouvre tout ou partie des opérations de traces, mains courantes et reconstitution d’opérations, historiques, signalement d’erreur, monitorat divers, etc. nous pouvons également dire d'une façon plus simple c'est procédé qui permet d'enregistrer des événements ou des informations qui surviennent au cours de l’exécution d'une application.

La méthode classique est d’utilisé System.out ou System.err deux classes Java qui permettent d’afficher des messages à la sortie standard (l’écran), c’est une méthode facile mais représente certaines limites comme l’absence de traçabilité comme le cas d'applications serveur ou la redondance de l’information. Cependant qu'un système de journalisation offre des fonctionnalités qui le rende plus souple, il permet de classer par niveaux chaque type message (débogage, information, Erreur, etc.), de définir le niveau minimum qu'un message doit avoir afin d’être filtré, d'enregistré et/ou le rediriger vers une sorties donnée. (Console, fichier, serveur de journalisation...).

Actuellement, nous trouvons plusieurs API de journalisation Log4J, Jylog, jLO… chacune d'elle apporte un petit plus en ajoutant des fonctionnalités plus au moins commode et une majorité d'entre elle s'appuie sur la classe Logger de la JDK celle que nous allons utiliser dans nos exemples. Dans un premier temps, nous allons écrire un programme Journalisation qui accédera à un dispositif de log pour poster simplement des informations en les catégorisant (niveau: trace, info, warning, error).

import java.util.logging.*;

public class Journalisation {
    public static void main(String args[]) {
        //De manière générale on peut dire qu’il y a un Logger 
        //par domaine fonctionnel. Souvent associé à la notion de package 
        //et portant le nom de ce package.
        Logger logger = Logger.getLogger("Journalisation");
        // Trace dans du code courant
        logger.log(Level.INFO, "!");
        try {
            int i = 15 / 0;
            System.out.println("Result: " + i);
        } catch (ArithmeticException exc) {
            // Trace dans d'une exception
            // ne remplace pas necessairement toutes les actions a prendre
            logger.log(Level.SEVERE, exc.getMessage());
        }
        // methode dérivée commodes d’acces
        logger.warning("ressource manquante...");
    }
}

Nous pouvons sur un Logger effectuer des réglages programmatiques pour le rendre plus efficace:

• Fixer un certain niveau de log et rejeter tout message d’importance inférieure setLevel(…)
  JournalisationLevel

  import java.util.logging.*; public class JournalisationLevel { public static void main(String args[]) { //De manière générale on peut dire qu’il y a un Logger //par domaine fonctionnel. Souvent associé à la notion de package //et portant le nom de ce package. Logger logger = Logger.getLogger("Journalisation"); //Fixer le niveau à des Warning logger.setLevel(Level.WARNING); // Trace dans du code courant logger.log(Level.INFO, "!"); try { int i = 15 / 0; System.out.println("Result: " + i); } catch (ArithmeticException exc) { // Trace dans d'une exception // ne remplace pas necessairement toutes les actions a prendre logger.log(Level.SEVERE, exc.getMessage()); } // methode dérivée commodes d’acces logger.warning("ressource manquante..."); } }

  
  Nous constatons que le premier événement de niveau information ne sera traité.
  
  
• Fixer spécifiquement un filtre programmatique chargé de rejeter certains rapports setFilter(…)
  JournalisationFiltre

  import java.util.logging.*; public class JournalisationFiltre { public static void main(String args[]) { //De manière générale on peut dire qu’il y a un Logger //par domaine fonctionnel. Souvent associé à la notion de package //et portant le nom de ce package. Logger logger = Logger.getLogger("Journalisation"); //Ajouter un filtre logger.setFilter(new Filter(){ // Redéfinir la méthode isLoggable de l'interface Filter pour filtre // tous les événements ayant comme messages "!" public boolean isLoggable(LogRecord event) { if(event.getMessage().equals("!")) return false; return true; } }); // Trace dans du code courant logger.log(Level.INFO, "!"); try { int i = 15 / 0; System.out.println("Result: " + i); } catch (ArithmeticException exc) { // Trace dans d'une exception // ne remplace pas necessairement toutes les actions a prendre logger.log(Level.SEVERE, exc.getMessage()); } // methode dérivée commodes d’acces logger.warning("ressource manquante..."); } }

  
  Nous constatons que le premier événement qui a comme message "!" ne sera traité.
  
  
• Les rapports sont ensuite propagés à un ou plusieurs traiteurs Handler qui vont transformer les enregistrements LogRecord et les mettre en forme pour le monde extérieur. addHandler(…). Les Handlers prédéfinis sont : FileHandler (log dans un ou plusieurs fichiers), StreamHandler (dans un flot d’E/S), ConsoleHandler (sur System.err), SocketHandler (sur des ports TCP distants). Nous ne sommes pas limite nous pouvons en crée d'autres, enfin sachez que chaque Handler peut aussi décider de filtrer ses messages et de mettre en forme les messages éventuellement en fonction de la langue (voir internationalisation).
  
  JournalisationHandler

  import java.util.logging.*; public class JournalisationHandler { public static void main(String args[]) { //De manière générale on peut dire qu’il y a un Logger //par domaine fonctionnel. Souvent associé à la notion de package et portant //le nom de ce package. Logger logger = Logger.getLogger("Journalisation"); //Ajouter un traiteur pour sauvegarder les événements dans un fichier. try { logger.addHandler(new FileHandler("File.log",true)); } catch (SecurityException e) { logger.warning(e.getMessage()); } catch (IOException e) { logger.warning(e.getMessage()); } // Trace dans du code courant logger.log(Level.INFO, "!"); try { int i = 15 / 0; System.out.println("Result: " + i); } catch (ArithmeticException exc) { // Trace dans d'une exception // ne remplace pas necessairement toutes les actions a prendre logger.log(Level.SEVERE, exc.getMessage()); } // methode dérivée commodes d’acces logger.warning("ressource manquante..."); } }

  
  Nous constatons qu'en plus de la sortie standard les événements sont sauvgarder dans un fichier.

Pour terminer j'ai mis à votre disposition deux programmes un qui nous permet de créer un nouveau handler sous forme d'IHM (JournalisationIHMHandler) et un autre pour définir un format "HTML" comme format de sauvgrade (JournalisationHTML)

Télécharger l'archive complet de ce tutoriel (Journalisation.zip)