Logging en Java suivant la convention

Le SDK Java dispose d'une quantité astronomique de classe et package qui peuvent être réutilisé pour gagner un temps considérable en développement.

C'est le cas du package java.util.logging. Ce paquet est une bibliothèque qui contient toute les classes de base nécessaire à l'écriture de log (journaux) en Java.

Pour cela on dispose de :

• la classe java.util.logging.Logger : c'est sur une instance de cette classe permet que l'on va envoyer nos logs. Un Logger peut exporter les logs qu'il reçoit vers une ou plusieurs sorties simultanées, appelé Handler.
• les java.util.logging.Handler : Java fourni déjà de base différents Handler (Console, Fichier, XML, Socket....). Par défaut, la classe Logger possède un seul Handler vers la sortie Console. Mais il est possible de rajouter des Handler au Logger.
• les java.util.logging.Formatter : les formatter sont des classes qui définissent la présentation des logs. Clairement, on définit via ces classes l'affichage qu'aura un java.util.logging.LogRecord (un enregistrement de log) à la sortie d'un Handler. Java fourni la classe SimpleFormatter par défaut pour la présentation des logs.
• java.util.logging.LogManager : une application possède une seul instance d'un LogManager (gestionnaire). Cette classe est utilisé notamment pour modifier la configuration des Logger de l'application, par exemple en chargeant la configuration depuis un fichier logging.properties.
• Fichier de configuration : l'un des point fort de l'API de logging de Java est qu'elle offre la possibilité de paramétrer simplement via un fichier de "properties", les Formatter et les Handler à utiliser, mais aussi le niveau de log à qui doit être exporté au niveau de chaque classe.

Classe métier rapportant des logs :

Voici un exemple de classe rapportant des logs. Dans la convention Java, on déclare un Logger statique pour chaque classe de l'application. Mais rien, n'oblige à suivre cette convention.

package org.rikutips.logger; import java.util.logging.Logger; public class Math { // Declare a static logger for the class private static final Logger logger = Logger.getLogger(Math.class.getName()); public static double divide(int a, int b) throws IllegalArgumentException { // You can mark that you enter in the method logger.entering(TestLogger.class.getName(), "divide"); double result = 0.0; IllegalArgumentException e = null; logger.info(String.format("Division %d/%d", a, b)); if(b != 0){ logger.fine("Processing the division"); result = ((double)a)/((double)b); }else{ // Log an error logger.severe("Divisor is 0"); e = new IllegalArgumentException("Divisor is 0"); } // You can mark that you leave the method logger.exiting(TestLogger.class.getName(), "divide"); if(e != null){ throw e; } return result; } }

Exemple de Formatter :

Admettons maintenant que l'on désire afficher nos logs avec uniquement le niveau de log et le texte de celui-ci.

On créé donc un formatter qu'on ajoutera à notre logger.

package org.rikutips.logger; import java.util.logging.Formatter; import java.util.logging.LogRecord; public class MyFormatter extends Formatter { @Override public String format(LogRecord record) { String strMsg; if("ENTRY".equals(record.getMessage())){ strMsg = String.format("entering [%s.%s]", record.getSourceClassName(), record.getSourceMethodName()); }else if ("RETURN".equals(record.getMessage())){ strMsg = String.format("exiting [%s.%s]", record.getSourceClassName(), record.getSourceMethodName()); }else{ strMsg = record.getMessage(); } return String.format("%-10s: %s\n", record.getLevel().getName(), strMsg); } }

Fichier de configuration :

On créé alors un fichier de configuration "logging.properties" :

############################################################ # Configuration fike the application. # To use it, launch the application with the following # parameter : # java -Djava.util.logging.config.file=myFile ... ############################################################ # Configuration of the client ############################################################ handlers = java.util.logging.ConsoleHandler # Formatter to use java.util.logging.ConsoleHandler.formatter=org.rikutips.logger.MyFormatter # Log level filter for the handler java.util.logging.ConsoleHandler.level = ALL ############################################################ # Log level to use for the application ############################################################ .level = INFO org.rikutips.logger.level = FINEST org.rikutips.logger.TestLogger.level = SEVERE

Il existe plusieurs façon de spécifier au programme l'utilisation d'un fichier de configuration.

• Passer une option à Java : "java -Djava.util.logging.config.file=/path/to/logging.properties ..."
• Utiliser le LogManager pour lire la configuration.

Lancement de l'application :

Et voici donc enfin la classe qui permet l'exécution du programme. Toutes les classes ainsi que le fichier de configuration sont placés dans un package "org.rikutips.logger".
On utilise donc le LogManager pour charger le fichier de configuration installer dans le package.

package org.rikutips.logger; import java.io.InputStream; import java.util.logging.LogManager; import java.util.logging.Logger; public class TestLogger { private static final Logger logger = Logger.getLogger(TestLogger.class.getName()); public static void main(String[] args) { logger.info("Starting application"); logger.fine("Loading configuration"); LogManager manager = LogManager.getLogManager(); InputStream is = TestLogger.class.getResourceAsStream("logging.properties"); try { manager.readConfiguration(is); } catch (Exception e) { logger.severe("Error to read the configuration"); } double res; try { res = Math.divide(1, 0); logger.info("Result=" + res); } catch (IllegalArgumentException e){ logger.severe("Error for the division"); } try { res = Math.divide(1, 2); logger.info("Result=" + res); } catch (IllegalArgumentException e){ logger.severe("Error for the division"); } } }

Voici alors ce qu'on obtient en sortie :

Dec 24, 2011 1:08:06 AM org.rikutips.logger.TestLogger main INFO: Starting application FINER : entering [org.rikutips.logger.TestLogger.divide] INFO : Division 1/0 SEVERE : Divisor is 0 FINER : exiting [org.rikutips.logger.TestLogger.divide] SEVERE : Error for the division FINER : entering [org.rikutips.logger.TestLogger.divide] INFO : Division 1/2 FINE : Processing the division FINER : exiting [org.rikutips.logger.TestLogger.divide]

Notez que la première ligne est affichée selon le format de la classe SimpleFormatter. Ceci est normal, du fait que au début du programme, la configuration n'est pas encore chargée.

Voilà, j'espère que ce tuto vous aura aidé à mieux comprendre la gestion des logs en Java.