Apprenez les bases de la journalisation Java

Java a incorporé une bibliothèque d'API de journalisation dans son cadre à partir de JDK 1.4. Aujourd'hui, il s'agit d'un support intégré de Java. Cependant, cette bibliothèque est personnalisable et extensible dans le sens où nous pouvons utiliser une ou plusieurs solutions de journalisation alternatives fournies par des bibliothèques tierces. Bien que ces solutions tierces aient une approche différente pour créer des données de journal, elles partagent finalement le même objectif de journalisation des messages à partir de l'exécution de l'application. Cet article explore les bases de la journalisation et montre comment elle peut être utilisée dans un programme Java.

Journalisation Java

Un journal signifie généralement le maintien d'une sorte de dossier. Du point de vue de la programmation, il s'agit d'un processus d'écriture de messages dans un fichier journal pendant l'exécution du programme. Les journaux de messages persistants sont référencés, généralement par le programmeur, pour collecter certaines informations statistiques d'exécution qui, une fois analysées, peuvent révéler des situations imprévues. En fait, il peut y avoir de nombreuses raisons distinctes pour lesquelles la journalisation est utilisée et ce n'est que l'une d'entre elles. Selon la documentation de l'API Java, il existe quatre utilisations principales de la journalisation :

• Pour le diagnostic des problèmes par les utilisateurs finaux et les administrateurs système.
• Il est pratique pour les techniciens de maintenance sur le terrain de diagnostiquer le problème à partir des messages enregistrés et de le résoudre rapidement.
• L'organisation de développement peut suivre l'exécution interne d'un sous-système particulier et l'analyser.
• Les développeurs peuvent déboguer l'application en cours de développement en obtenant un aperçu rapide du problème sous-jacent à partir des messages enregistrés.

La journalisation de l'API Java est conçue de manière peu coûteuse dans le sens où elle peut être laissée comme un résidu même dans une application de production. Cela ne crée pas beaucoup de surcharge pour l'efficacité de l'exécution du programme. L'API fournit le mécanisme permettant de modifier la production de messages de journal de manière dynamique afin que l'impact de la journalisation puisse être minimisé lors des opérations nécessitant une efficacité maximale. L'API se compose d'un certain nombre de classes et d'interfaces qui peuvent être personnalisées en les étendant. L'intégralité de l'API de journalisation est regroupée sous java.util.logging . Les classes et les interfaces de ce package fournissent les principales fonctionnalités de journalisation de Java.

Niveaux de journalisation

L'urgence de se connecter à un programme Java peut être classée en plusieurs niveaux. En nivelant vers le haut et vers le bas, nous pouvons augmenter ou diminuer le coût de la journalisation dans une application de production. C'est ainsi que nous contrôlons l'efficacité d'exécution d'une application lorsqu'il est nécessaire de journaliser un ou plusieurs de ses événements. Ceci est réalisé grâce à une classe appelée Level , qui définit l'importance de la journalisation. Le niveau de journalisation est ordonné et spécifié par static constantes entières, telles que :

• Niveau.ALL : Tous les messages sont enregistrés, quelle que soit leur importance
• Niveau.OFF : La journalisation est désactivée
• Niveau.SEVERE : Indique une défaillance grave ; doit être connecté
• Niveau.ATTENTION : Indique des messages d'avertissement
• Niveau.INFO : Message d'information d'exécution
• Niveau.CONFIG : Messages de configuration statiques
• Niveau.FINE : Suivi des messages
• Niveau.FINER : Messages de suivi détaillés
• Niveau.FINEST : Messages de suivi très détaillés

Composants de journalisation

Nous avons besoin d'un enregistreur instance pour effectuer n'importe quel type de journalisation en Java. Cette instance est responsable de la journalisation des données dans un LogRecord . Le LogRecord les instances sont utilisées pour transmettre les requêtes de journalisation entre les frameworks de journalisation et les gestionnaires de journaux individuels. Java SE fournit cinq types de gestionnaires intégrés :StreamHandler , ConsoleHandler , FileHandler , SocketHandler , et MemoryHandler . On peut cependant créer un nouveau gestionnaire ou étendre l'un de ceux-ci en tant que personnalisation. Les gestionnaires déterminent ce qu'il faut faire avec l'enregistrement du journal ; par exemple, il peut être conservé dans un référentiel local ou transmis à un serveur sur un réseau. Java SE inclut également deux formateurs standard :SimpleFormatter et XMLFormatter . Ces formateurs sont utilisés pour formater un LogRecord respectivement au format lisible par l'homme et au format XML standard.

Il existe un LogManager classe qui garde une trace des informations de journalisation globales, comme un espace de noms hiérarchique de Loggers nommés et un ensemble de propriétés de contrôle de journalisation à partir du fichier de configuration. Il est au cœur de la journalisation en Java et contrôle à peu près quoi enregistrer, où enregistrer, y compris d'autres détails d'initialisation, etc.

Un exemple de journalisation simple

Création d'un enregistreur objet est très simple. Voici un code très simple pour illustrer cela.

import java.util.logging.Logger;
public class App {
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) {
      logger.info("This is a log message  !!!");
      logger.info("The name of the logger is " +
         logger.getName() + " nwhich is same as class name: "
            + App.class.getName());
   }
}

Enregistreur les objets sont généralement nommés à l'aide de la chaîne valeur d'un espace de noms hiérarchique séparé par des points. Dans le cas précédent, c'est le même que le nom de la classe. Le nom, cependant, peut être une valeur String arbitraire, mais normalement les noms sont basés sur le nom du package ou le nom de la classe du composant journalisé. Il est également possible de créer un logger "anonyme" qui ne sera pas stocké dans le Logger espace de noms.

Se connecter à un fichier externe à l'aide du formatage XML

Dans le code suivant, les messages du journal sont redirigés vers un fichier à l'aide de FileHandler .

Le gestionnaire de fichiers peut soit écrire dans un fichier spécifié, soit écrire dans un ensemble rotatif de fichiers. L'ensemble de fichiers rotatif signifie que les fichiers plus anciens sont nommés en ajoutant 0,1,2 et ainsi de suite dans le nom de fichier de base. Le XMLFormatter est le formatage par défaut utilisé par FileHandler .

import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
   private static FileHandler fileHandler;
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) throws
         IOException {
      fileHandler = new
         FileHandler(App.class.getName() + ".log");
      logger.setLevel(Level.ALL);
      logger.addHandler(fileHandler);
      logger.info("Log message redirected to a file");
      logger.info("The name of the logger is " +
         logger.getName() + 
            " nwhich is same as class name: "
            + App.class.getName());
   }
}

Connexion à un fichier externe à l'aide d'un formatage personnalisé

Nous allons modifier un peu le code suivant pour personnaliser la mise en forme du message. Cela change la façon dont les messages sont écrits dans le fichier externe.

import java.io.IOException;
import java.util.logging.*;
public class App {
   private static FileHandler fileHandler;
   private static Logger logger =
      Logger.getLogger(App.class.getName());
   public static void main(String[] args) throws
         IOException {
      fileHandler = new
         FileHandler(App.class.getName() + ".log");
      logger.setLevel(Level.ALL);
      fileHandler.setFormatter(newCustomFormatter());
      logger.addHandler(fileHandler);
      logger.fine("Log message redirected to a file");
      logger.finer("The name of the logger is " +
         logger.getName());
      loggerfinest("This is same as class name: " +
         App.class.getName());
   }
   private static class CustomFormatter extends Formatter {
      private static final String format =
          "[%1$tF %1$tT] [%2$-4s] %3$s %n";
      public String format(LogRecord record) {
         returnString.format(format,
            record.getMillis(),
            record.getLevel().getLocalizedName(),
            record.getMessage());
      }
   }
}

C'est tout. Expérimentez avec la journalisation Java et essayez de nombreuses autres possibilités. Consultez les documents de l'API Java si nécessaire.

Autres frameworks de journalisation en Java

Parfois, il est pratique d'utiliser un framework de journalisation tiers, et il y en a plusieurs parmi lesquels choisir. Par exemple, l'API de journalisation fournie par SLF4J utilise un modèle de façade simple qui est une couche d'abstraction qui permet à l'application d'être découplée de son framework de journalisation. Log4j est syntaxiquement similaire à la journalisation Java intégrée. Il a une configuration par défaut pour envoyer tous les messages du journal à la console. Logback est un successeur de Log4j et est une extension de son prédécesseur. tinyLog est un framework de journalisation léger qui peut être utilisé avec Java et Android.

Conclusion

Le processus de journalisation est conçu pour être simple et efficace dans la livraison de ce qu'il est censé faire. Il est possible de démarrer rapidement avec les API Logging en Java. La conception est extensible et peut être personnalisée en fonction des besoins finaux du développeur. Cet article est un aperçu des bases de la journalisation Java. De nombreux détails complexes sont omis pour plus de simplicité. Étudiez la documentation de l'API Java et d'autres documents appropriés pour plus de détails à ce sujet.

Références

• Présentation de la journalisation Java
• Documentation de l'API Java