SLF4J - Guide rapide

SLF4J signifie Simpulser Logging Facade pour Java. Il fournit une abstraction simple de tous les frameworks de journalisation en Java. Ainsi, il permet à un utilisateur de travailler avec l'un des cadres de journalisation tels que Log4j, Logback etJUL(java.util.logging) en utilisant une dépendance unique. Vous pouvez migrer vers l'infrastructure de journalisation requise au moment de l'exécution / du déploiement.

Ceki Gülcü a créé SLF4J comme alternative au cadre de journalisation des communs de Jakarta.

Avantages de SLF4J

Voici les avantages de SLF4J -

À l'aide de la structure SLF4J, vous pouvez migrer vers la structure de journalisation souhaitée au moment du déploiement.
Slf4J fournit des liaisons à tous les frameworks de journalisation courants tels que log4j, JUL, Simple logging et NOP. Par conséquent, vous pouvez basculer vers l'un de ces frameworks populaires au moment du déploiement.
SLF4J prend en charge les messages de journalisation paramétrés indépendamment de la liaison que vous utilisez.
Étant donné que SLF4J dissocie l'application et le cadre de journalisation, vous pouvez facilement écrire des applications indépendamment des cadres de journalisation. Vous n'avez pas à vous soucier du cadre de journalisation utilisé pour écrire une application.
SLF4J fournit un outil Java simple appelé migrateur. En utilisant cet outil, vous pouvez migrer des projets existants, qui utilisent des cadres de journalisation comme Jakarta Commons Logging (JCL) ou, log4j ou, Java.util.logging (JUL) vers SLF4J.

La connexion à la programmation fait référence à l'enregistrement des activités / événements. Habituellement, les développeurs d'applications doivent s'occuper de la journalisation.

Pour faciliter le travail de journalisation, Java fournit divers frameworks - log4J, java.util.logging (JUL), tiny log, logback, etc.

Présentation du cadre de journalisation

Un cadre de journalisation contient généralement trois éléments -

Enregistreur

Capture le message avec les métadonnées.

Formateur

Formate les messages capturés par l'enregistreur.

Gestionnaire

Le Handler ou l'appender distribue finalement les messages soit en les imprimant sur la console, soit en les stockant dans la base de données ou en les envoyant via un email.

Certains frameworks combinent les éléments logger et appender pour accélérer les opérations.

Objet Logger

Pour consigner un message, l'application envoie un objet de journalisation (parfois avec les exceptions le cas échéant) avec le nom et le niveau de sécurité.

Degré de gravité

Les messages enregistrés seront de différents niveaux. Le tableau suivant répertorie les niveaux généraux de journalisation.

Sr.Non	Niveau de gravité et description
1	Fatal Problème grave entraînant l'arrêt de l'application.
2	ERROR Erreurs d'exécution.
3	WARNING Dans la plupart des cas, les erreurs sont dues à l'utilisation d'API obsolètes.
4	INFO Événements qui se produisent lors de l'exécution.
5	DEBUG Informations sur le flux du système.
6	TRACE Des informations plus détaillées sur le flux du système.

Qu'est-ce que log4j?

log4j est une solution fiable, rapide et flexible logging framework (APIs) written in Java, qui est distribué sous la licence du logiciel Apache.

log4j est hautement configurable via des fichiers de configuration externes au moment de l'exécution. Il voit le processus de journalisation en termes de niveaux de priorités et offre des mécanismes pour diriger les informations de journalisation vers une grande variété de destinations, telles qu'une base de données, un fichier, une console, UNIX Syslog, etc. (pour plus de détails sur log4j, reportez-vous à notre Tutoriel ).

Comparaison SLF4J et Log4j

Contrairement à log4j, SLF4J (Simpulser Logging Facade pour Java) n'est pas une implémentation du cadre de journalisation, c'est un abstraction for all those logging frameworks in Java similar to log4J. Par conséquent, vous ne pouvez pas comparer les deux. Cependant, il est toujours difficile d'en préférer un entre les deux.

Si vous avez le choix, l'abstraction de journalisation est toujours préférable à la structure de journalisation. Si vous utilisez une abstraction de journalisation, SLF4J en particulier, vous pouvez migrer vers n'importe quelle infrastructure de journalisation dont vous avez besoin au moment du déploiement sans opter pour une dépendance unique.

Observez le schéma suivant pour avoir une meilleure compréhension.

Dans ce chapitre, nous expliquerons comment définir l'environnement SLF4J dans Eclipse IDE. Avant de procéder à l'installation, assurez-vous que Eclipse est déjà installé sur votre système. Sinon, téléchargez et installez Eclipse.

Pour plus d'informations sur Eclipse, veuillez consulter notre Tutoriel Eclipse

Étape 1: Téléchargez le fichier JAR de dépendance

Ouvrez la page d' accueil officielle du site Web SLF4J et accédez à la page de téléchargement.

Maintenant, téléchargez la dernière version stable de slf4j-X.X.tar.gzou slf4j-XXzip , selon votre système d'exploitation (si fichier windows .zip ou si fichier Linux tar.gz).

Dans le dossier téléchargé, vous trouverez slf4j-api-XXjar . Il s'agit du fichier Jar requis.

Étape 2: créer un projet et définir le chemin de génération

Ouvrez eclipse et créez un exemple de projet. Faites un clic droit sur le projet, sélectionnez l'optionBuild Path → Configure Build Path… comme indiqué ci-dessous.

dans le Java Build Path cadre dans le Libraries onglet, cliquez sur Add External JARs…

Sélectionnez le slf4j-api.x.x.jar fichier téléchargé et cliquez sur Apply and Close.

Fixations SLF4J

En plus de slf4j-api.x.x.jar fichier, SLF4Jfournit plusieurs autres fichiers Jar comme indiqué ci-dessous. Ceux-ci sont appelésSLF4J bindings.

Où chaque liaison est pour son cadre de journalisation respectif.

Le tableau suivant répertorie les liaisons SLF4J et leurs frameworks correspondants.

Sr.Non	Fichier Jar et cadre de journalisation
1	slf4j-nop-x.x.jar Aucune opération, supprime tous les enregistrements.
2	slf4j-simple-x.x.jar Implémentation simple où les messages pour info et plus sont imprimés et, restant toutes les sorties vers System.err.
3	slf4j-jcl-x.x.jar Cadre de journalisation Jakarta Commons.
4	slf4j-jdk14-x.x.jar Framework Java.util.logging (JUL).
5	slf4j-log4j12-x.x.jar Cadre de travail Log4J. De plus, vous devez avoirlog4j.jar.

Pour que SLF4J fonctionne avec slf4l-api-xxjar, vous devez ajouter le fichier Jar respectif (liaison) du framework de journalisation souhaité dans le chemin de classe du projet (définir le chemin de construction).

Pour passer d'un framework à l'autre, vous devez remplacer la liaison respective. Si aucune limite n'est trouvée, il passe par défaut en mode sans opération.

Pom.xml pour SLF4J

Si vous créez le projet maven, ouvrez le pom.xml et collez-y le contenu suivant et actualisez le projet.

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>Sample</groupId>
   <artifactId>Sample</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
      </plugins>
   </build>
   <dependencies>
      <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-api</artifactId>
         <version>1.7.25</version>
      </dependency>
   </dependencies>
</project>

Dans ce chapitre, nous discuterons des classes et des méthodes que nous utiliserons dans les chapitres suivants de ce tutoriel.

Interface de l'enregistreur

L'interface enregistreur du org.slf4jpackage est le point d'entrée de l'API SLF4J. La liste suivante répertorie les méthodes importantes de cette interface.

Sr.No.	Méthodes et description
1	void debug(String msg) Cette méthode enregistre un message au niveau DEBUG.
2	void error(String msg) Cette méthode enregistre un message au niveau ERROR.
3	void info(String msg) Cette méthode enregistre un message au niveau INFO.
4	void trace(String msg) Cette méthode enregistre un message au niveau TRACE.
5	void warn(String msg) Cette méthode enregistre un message au niveau WARN.

Classe LoggerFactory

La classe LoggerFactory du org.slf4j package est une classe d'utilitaires, qui est utilisée pour générer des enregistreurs pour diverses API de journalisation telles que log4j, JUL, NOP et simple logger.

Sr.No.	Méthode et description
1	Logger getLogger(String name) Cette méthode accepte une valeur de chaîne représentant un nom et renvoie un Logger objet avec le nom spécifié.

Classe de profileur

Cette classe appartient au package org.slf4jil est utilisé à des fins de profilage et il est connu sous le nom de profileur du pauvre. Grâce à cela, le programmeur peut connaître le temps nécessaire pour effectuer des tâches prolongées.

Voici les méthodes importantes de cette classe.

Sr.No.	Méthodes et description
1	void start(String name) Cette méthode démarre un nouveau chronomètre enfant (nommé) et arrête les chronomètres enfants précédents (ou instruments de temps).
2	TimeInstrument stop() Cette méthode arrêtera le chronomètre enfant récent et le chronomètre global et retournera l'instrument de temps actuel.
3	void setLogger(Logger logger) Cette méthode accepte un objet Logger et associe le logger spécifié au Profiler actuel.
4	void log() Enregistre le contenu de l'instrument de temps actuel associé à un enregistreur.
5	void print() Imprime le contenu de l'instrument de temps actuel.

Dans ce chapitre, nous verrons un simple programme d'enregistrement de base utilisant SLF4J. Suivez les étapes décrites ci-dessous pour écrire un simple enregistreur.

Étape 1 - Créez un objet de l'interface slf4j.Logger

Depuis le slf4j.Logger est le point d'entrée de l'API SLF4J, tout d'abord, vous devez obtenir / créer son objet

le getLogger() méthode de la LoggerFactory class accepte une valeur de chaîne représentant un nom et renvoie un Logger objet avec le nom spécifié.

Logger logger = LoggerFactory.getLogger("SampleLogger");

Étape 2 - Enregistrez le message requis

le info() méthode de la slf4j.Logger interface accepte une valeur de chaîne représentant le message requis et le consigne au niveau info.

logger.info("Hi This is my first SLF4J program");

Exemple

Voici le programme qui montre comment écrire un exemple d'enregistreur en Java à l'aide de SLF4J.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger("SampleLogger");

      //Logging the information
      logger.info("Hi This is my first SLF4J program");
   }
}

Production

Lors de l'exécution initiale du programme suivant, vous obtiendrez la sortie suivante au lieu du message souhaité.

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

Étant donné que nous n'avons défini le classpath sur aucune liaison représentant un cadre de journalisation, comme mentionné précédemment dans ce didacticiel, SLF4J a utilisé par défaut une implémentation sans opération. Donc, pour voir le message, vous devez ajouter la liaison souhaitée dans le chemin de classe du projet. Puisque nous utilisons eclipse, définissezbuild path pour le fichier JAR respectif ou, ajoutez sa dépendance dans le fichier pom.xml.

Par exemple, si nous devons utiliser JUL (framework Java.util.logging), nous devons définir le chemin de construction pour le fichier jar slf4j-jdk14-x.x.jar. Et si nous voulons utiliser le cadre de journalisation log4J, nous devons définir le chemin de construction ou ajouter des dépendances pour les fichiers jarslf4j-log4j12-x.x.jar et log4j.jar.

Après avoir ajouté la liaison représentant l'un des frameworks de journalisation sauf slf4j-nopx.x.jar au projet (classpath), vous obtiendrez la sortie suivante.

Dec 06, 2018 5:29:44 PM SLF4JExample main
INFO: Hi Welcome to Tutorialspoint

Dans ce chapitre, nous discuterons des différents messages d'erreur ou avertissements que nous recevons en travaillant avec SLF4J et des causes / significations de ces messages.

Échec du chargement de la classe «org.slf4j.impl.StaticLoggerBinder».

Il s'agit d'un avertissement qui se produit lorsqu'aucune liaison SLF4J n'est fournie dans le chemin de classe.

Voici l'avertissement complet -

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further
details.

Pour résoudre ce problème, vous devez ajouter l'une des liaisons de l'infrastructure de journalisation. Ceci est expliqué dans leHello world chapitre de ce tutoriel.

Note - Cela se produit dans les versions de SLF4J qui sont entre 1.6.0 et 1.8.0-beta2.

Aucun fournisseur SLF4J n'a été trouvé

Dans slf4j-1.8.0-beta2, l'avertissement ci-dessus est plus clair “No SLF4J providers were found”.

Voici l'avertissement complet -

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.

Classpath contient des liaisons SLF4J ciblant les versions slf4j-api antérieures à 1.8

Si vous utilisez la version SLF4J 1.8 et que vous avez les liaisons des versions précédentes dans le chemin de classe mais pas les liaisons de 1.8, vous verrez un avertissement comme indiqué ci-dessous.

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
SLF4J: Class path contains SLF4J bindings targeting slf4j-api versions prior to
1.8.
SLF4J: Ignoring binding found at
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#ignoredBindings for an explanation.

NoClassDefFoundError: org / apache / commons / logging / LogFactory

Si vous travaillez avec slf4j-jcl et si vous n'avez que slf4j-jcl.jar dans votre classpath, vous obtiendrez une exception telle que celle donnée ci-dessous.

Exception in thread "main" java.lang.NoClassDefFoundError:
org/apache/commons/logging/LogFactory
   at org.slf4j.impl.JCLLoggerFactory.getLogger(JCLLoggerFactory.java:77)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:358)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.ClassNotFoundException:
org.apache.commons.logging.LogFactory
   at java.net.URLClassLoader.findClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
   at java.lang.ClassLoader.loadClass(Unknown Source)
   ... 3 more

Pour résoudre ce problème, vous devez ajouter commons-logging.jar à votre chemin de classe.

Détecté à la fois jcl-over-slf4j.jar ET lié slf4j-jcl.jar sur le chemin de classe.

La reliure slf4j-jcl.jar redirige les appels de l'enregistreur slf4j vers JCL et le jcl-over-slf4j.jarredirige les appels de l'enregistreur JCL vers slf4j. Par conséquent, vous ne pouvez pas avoir les deux dans le chemin de classe de votre projet. Si vous le faites, vous obtiendrez une exception telle que celle indiquée ci-dessous.

SLF4J: Detected both jcl-over-slf4j.jar AND bound slf4j-jcl.jar on the class
path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#jclDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:71)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:42)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both jcl-over-slf4j.jar
AND bound slf4j-jcl.jar on the class path, preempting StackOverflowError. See
also http://www.slf4j.org/codes.html#jclDelegationLoop for more details.
   at org.slf4j.impl.JCLLoggerFactory.<clinit>(JCLLoggerFactory.java:54)
   ... 7 more

Pour résoudre ce problème, supprimez l'un des fichiers jar.

Non-concordance du nom de l'enregistreur détecté

Vous pouvez créer un objet Logger en -

Passer le nom de l'enregistreur à créer comme argument au getLogger() méthode.
Passer une classe comme argument à cette méthode.

Si vous essayez de créer l'objet de fabrique de journaux en transmettant une classe comme argument, et si vous avez défini la propriété système slf4j.detectLoggerNameMismatch à true, puis le nom de la classe que vous passez comme argument au getLogger() et la classe que vous utilisez doivent être les mêmes, sinon vous recevrez l'avertissement suivant -

«Non-concordance de nom d'enregistreur détectée.

Prenons l'exemple suivant.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JExample {
   public static void main(String[] args) {
      System.setProperty("slf4j.detectLoggerNameMismatch", "true");
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Hi Welcome to Tutorilspoint");
   }
}

Ici, nous avons défini la propriété slf4j.detectLoggerNameMismatch sur true. Le nom de la classe que nous avons utilisé estSLF4JExample et le nom de classe que nous avons passé à la méthode getLogger () est Sample comme ils ne sont pas tous les deux égaux, nous recevrons l'avertissement suivant.

SLF4J: Detected logger name mismatch. Given name: "Sample"; computed name:
"SLF4JExample".
SLF4J: See http://www.slf4j.org/codes.html#loggerNameMismatch for an
explanation
Dec 10, 2018 12:43:00 PM SLF4JExample main
INFO: Hi Welcome to Tutorilspoint

Note - Cela se produit après slf4j 1.7.9

Classpath contient plusieurs liaisons SLF4J.

Vous ne devriez avoir qu'une seule liaison dans le chemin de classe. Si vous disposez de plusieurs liaisons, vous recevrez un avertissement répertoriant les liaisons et leur emplacement.

Par exemple, si nous avons les liaisons slf4j-jdk14.jar et slf4j-nop.jar dans le classpath, nous obtiendrons l'avertissement suivant.

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-nop-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in
[jar:file:/C:/Users/Tutorialspoint/Desktop/Latest%20Tutorials/SLF4J%20Tutorial/
slf4j-1.7.25/slf4j-jdk14-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an
explanation.
SLF4J: Actual binding is of type [org.slf4j.helpers.NOPLoggerFactory]

Détecté à la fois log4j-over-slf4j.jar ET lié slf4j-log4j12.jar sur le chemin de classe

Pour rediriger les appels du journal log4j vers slf4j, vous devez utiliser log4j-over-slf4j.jar liaison et si vous souhaitez rediriger les appels slf4j vers log4j, vous devez utiliser slf4j-log4j12.jar contraignant.

Par conséquent, vous ne pouvez pas avoir les deux dans le chemin de classe. Si vous le faites, vous obtiendrez l'exception suivante.

SLF4J: Detected both log4j-over-slf4j.jar AND bound slf4j-log4j12.jar on the
class path, preempting StackOverflowError.
SLF4J: See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more
details.
Exception in thread "main" java.lang.ExceptionInInitializerError
   at org.slf4j.impl.StaticLoggerBinder.<init>(StaticLoggerBinder.java:72)
   at org.slf4j.impl.StaticLoggerBinder.<clinit>(StaticLoggerBinder.java:45)
   at org.slf4j.LoggerFactory.bind(LoggerFactory.java:150)
   at org.slf4j.LoggerFactory.performInitialization(LoggerFactory.java:124)
   at org.slf4j.LoggerFactory.getILoggerFactory(LoggerFactory.java:412)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:357)
   at org.slf4j.LoggerFactory.getLogger(LoggerFactory.java:383)
   at SLF4JExample.main(SLF4JExample.java:8)
Caused by: java.lang.IllegalStateException: Detected both log4j-over-slf4j.jar
AND bound slf4j-log4j12.jar on the class path, preempting StackOverflowError.
See also http://www.slf4j.org/codes.html#log4jDelegationLoop for more details.

Comme indiqué précédemment dans ce didacticiel, SLF4J prend en charge les messages de journal paramétrés.

Vous pouvez utiliser des paramètres dans les messages et leur transmettre des valeurs ultérieurement dans la même instruction.

Syntaxe

Comme indiqué ci-dessous, vous devez utiliser des espaces réservés ({}) dans le message (String) partout où vous en avez besoin et plus tard, vous pouvez transmettre la valeur de l'espace réservé dans object formulaire, en séparant le message et la valeur par une virgule.

Integer age;
Logger.info("At the age of {} ramu got his first job", age);

Exemple

L'exemple suivant illustre la journalisation paramétrée (avec un seul paramètre) à l'aide de SLF4J.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      
      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(PlaceHolders.class);
      Integer age = 23;
      
      //Logging the information
      logger.info("At the age of {} ramu got his first job", age);
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante -

Dec 10, 2018 3:25:45 PM PlaceHolders main
INFO: At the age of 23 Ramu got his first job

Avantage de la journalisation paramétrée

En Java, si nous devons imprimer des valeurs dans une instruction, nous utiliserons l'opérateur de concaténation comme -

System.out.println("At the age of "+23+" ramu got his first job");

Cela implique la conversion de la valeur entière 23 en chaîne et la concaténation de cette valeur avec les chaînes qui l'entourent.

Et s'il s'agit d'une instruction de journalisation, et si ce niveau de journalisation particulier de votre instruction est désactivé, tout ce calcul ne sera d'aucune utilité.

Dans de telles circonstances, vous pouvez utiliser la journalisation paramétrée. Dans ce format, SLF4J confirme initialement si la journalisation pour un niveau particulier est activée. Si tel est le cas, il remplace les espaces réservés dans les messages par les valeurs respectives.

Par exemple, si nous avons une instruction comme

Integer age;
Logger.debug("At the age of {} ramu got his first job", age);

Seulement si le débogage est activé, SLF4J convertit l'âge en entier et le concatène avec les chaînes sinon, il ne fait rien. Cela entraîne ainsi le coût de construction des paramètres lorsque le niveau de journalisation est désactivé.

Variante à deux arguments

Vous pouvez également utiliser deux paramètres dans un message comme -

logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);

Exemple

L'exemple suivant illustre l'utilisation de deux espaces réservés dans la journalisation paramétrée.

import java.util.Scanner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PlaceHolders {
   public static void main(String[] args) {
      Integer oldWeight;
      Integer newWeight;
      Scanner sc = new Scanner(System.in);
      System.out.println("Enter old weight:");
      oldWeight = sc.nextInt();

      System.out.println("Enter new weight:");
      newWeight = sc.nextInt();

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("Old weight is {}. new weight is {}.", oldWeight, newWeight);
 
      //Logging the information
      logger.info("After the program weight reduced is: "+(oldWeight-newWeight));
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante.

Enter old weight:
85
Enter new weight:
74
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: Old weight is 85. new weight is 74.
Dec 10, 2018 4:12:31 PM PlaceHolders main
INFO: After the program weight reduced is: 11

Variante d'argument multiple

Vous pouvez également utiliser plus de deux espaces réservés, comme illustré dans l'exemple suivant -

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PlaceHolders {
   public static void main(String[] args) {
      Integer age = 24;
      String designation = "Software Engineer";
      String company = "Infosys";

      //Creating the Logger object
      Logger logger = LoggerFactory.getLogger(Sample.class);

      //Logging the information
      logger.info("At the age of {} ramu got his first job as a {} at {}", age, designation, company);
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante -

Dec 10, 2018 4:23:52 PM PlaceHolders main
INFO: At the age of 24 ramu got his first job as a Software Engineer at Infosys

Si vous avez un projet dans Jakarta Commons Logging (JCL) ou, log4j ou, java.util.logging (JUL) et que vous souhaitez convertir ces projets en SLF4J, vous pouvez le faire à l'aide de l'outil de migration fourni dans la distribution SLF4J.

Exécution du migrateur SLF4J

SLF4J est un simple fichier jar (slf4j-migrator.jar) et vous pouvez l'exécuter à l'aide de la commande java –jar.

Pour l'exécuter, dans l'invite de commande, parcourez le répertoire dans lequel vous avez ce fichier jar et exécutez la commande suivante.

java -jar slf4j-migrator-1.8.0-beta2.jar
Starting SLF4J Migrator

Cela démarre le migrateur et vous pouvez voir une application Java autonome comme -

Comme spécifié dans la fenêtre, vous devez cocher le type de migration que vous souhaitez effectuer et sélectionner le répertoire du projet et cliquer sur le bouton Migrer le projet vers SLF4J.

Cet outil accède aux fichiers source que vous fournissez et effectue des modifications simples comme la modification des lignes d'importation et des déclarations de journalisation du cadre de journalisation actuel vers SLF4j.

Exemple

Par exemple, supposons que nous ayons un échantillon log4j(2) projet en éclipse avec un seul fichier comme suit -

import org.apache.log4j.Logger;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(Sample.class.getName());

   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Pour migrer l'échantillon log4j(2) projet vers slf4j, nous devons cocher le bouton radio from log4j to slf4j et sélectionnez le répertoire du projet et cliquez sur Exit migrer.

Le migrateur a modifié le code ci-dessus comme suit. Ici, si vous observez que les instructions d'importation et de journalisation ont été modifiées.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class Sample {
   static Logger log = LoggerFactory.getLogger(Sample.class.getName());
   public static void main(String[] args)throws IOException,SQLException {
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Puisque vous avez déjà log4j.jar dans votre projet, vous devez ajouter slf4j-api.jar et slf4jlog12.jar fichiers au projet pour l'exécuter.

Limitations de SLF4JMigrator

Voici les limites du migrateur SLF4J.

Migrator ne modifiera pas les scripts de construction comme ant, maven et, ivy dont vous avez besoin pour le faire vous-même.
Migrator ne prend pas en charge les messages autres que le type String.
Migrator ne prend pas en charge le niveau FATAL.
Lorsque vous travaillez avec log4j, Migrator ne migre pas les appels vers PropertyConfigurator ou DomConfigurator.

SLF4J Distribution fournit slf4j-ext.jar il contient des API pour les fonctionnalités telles que le profilage, la journalisation étendue, la journalisation des événements et la journalisation avec l'agent Java.

Profilage

Parfois, le programmeur veut mesurer certains attributs comme l'utilisation de la mémoire, la complexité du temps ou l'utilisation d'instructions particulières sur les programmes pour mesurer la capacité réelle de ce programme. Ce type de mesure du programme s'appelle le profilage. Le profilage utilise une analyse de programme dynamique pour effectuer une telle mesure.

SLF4J fournit une classe nommée Profiler dans le org.slf4j.profilerpackage à des fins de profilage. C'est ce qu'on appelle le profileur du pauvre. Grâce à cela, le programmeur peut connaître le temps nécessaire pour effectuer des tâches prolongées.

Profilage à l'aide de la classe Profiler

Le profileur contient des chronomètres et des chronomètres enfants et nous pouvons les démarrer et les arrêter en utilisant les méthodes fournies par la classe profiler.

Pour poursuivre le profilage à l'aide de la classe profiler, suivez les étapes ci-dessous.

Étape 1 - Instancier la classe du profileur

Instanciez la classe Profiler en passant une valeur String représentant le nom du profileur. Lorsque nous instancions une classe Profiler, un chronomètre global sera lancé.

//Creating a profiler
Profiler profiler = new Profiler("Sample");

Étape 2 - Démarrer un chronomètre enfant

Lorsque nous invoquons le start() méthode, il démarrera un nouveau chronomètre enfant (nommé) et arrête les chronomètres enfants précédents (ou instruments de temps).

Invoquez le start() méthode de la Profiler class en passant une valeur String représentant le nom du chronomètre enfant à créer.

//Starting a child stopwatch and stopping the previous one.
profiler.start("Task 1");
obj.demoMethod1();

Après avoir créé ces chronomètres, vous pouvez effectuer vos tâches ou appeler ces méthodes qui exécutent vos tâches.

Étape 3: Démarrez un autre chronomètre enfant (si vous le souhaitez)

Si vous en avez besoin, créez un autre chronomètre à l'aide du start()méthode et exécutez les tâches requises. Si vous le faites, il démarrera un nouveau chronomètre et arrêtera le précédent (c'est-à-dire la tâche 1).

//Starting another child stopwatch and stopping the previous one.
profiler.start("Task 2");
obj.demoMethod2();

Étape 4: Arrêtez les montres

Lorsque nous invoquons le stop() méthode, il arrêtera le chronomètre enfant récent et le chronomètre global et retournera l'instrument de temps actuel.

// Stopping the current child stopwatch and the global stopwatch.
TimeInstrument tm = profiler.stop();

Étape 5: Imprimez le contenu de l'instrument de temps.

Imprimez le contenu de l'instrument d'heure actuelle à l'aide du print() méthode.

//printing the contents of the time instrument
tm.print();

Exemple

L'exemple suivant illustre le profilage à l'aide de la classe Profiler de SLF4J. Ici, nous avons pris deux exemples de tâches, en imprimant la somme des carrés des nombres de 1 à 10000, en imprimant la somme des nombres de 1 à 10000. Nous essayons d'obtenir le temps nécessaire pour ces deux tâches.

import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample obj = new ProfilerExample();

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();
 
      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //printing the contents of the time instrument
      tm.print();
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante -

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000
+ Profiler [BASIC]
|-- elapsed time [Task 1] 2291.827 microseconds.
|-- elapsed time [Task 2] 225.802 microseconds.
|-- Total [BASIC] 3221.598 microseconds.

Journalisation des informations du profileur

Au lieu d'imprimer le résultat d'un profileur pour consigner ces informations, vous devez -

Créez un enregistreur à l'aide du LoggerFactory classe.
Créez un profileur en instanciant la classe Profiler.
Associez le logger au profiler en passant l'objet logger créé au setLogger() méthode de la Profiler classe.
Enfin, au lieu d'imprimer le journal, les informations du profileur à l'aide du log() méthode.

Exemple

Dans l'exemple suivant, contrairement au précédent (au lieu d'imprimer), nous essayons de consigner le contenu de l'instrument de temps.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.profiler.Profiler;
import org.slf4j.profiler.TimeInstrument;

public class ProfilerExample_logger {
   public void demoMethod1(){
      double sum = 0;
      for(int i=0; i< 1000; i++){
         sum = sum+(Math.pow(i, 2));
      }
      System.out.println("Sum of squares of the numbers from 1 to 10000: "+sum);
   }
   public void demoMethod2(){
      int sum = 0;
      for(int i=0; i< 10000; i++){
         sum = sum+i;
      }
      System.out.println("Sum of the numbers from 1 to 10000: "+sum);
   }
   public static void main(String[] args) {
      ProfilerExample_logger obj = new ProfilerExample_logger();

      //Creating a logger
      Logger logger = LoggerFactory.getLogger(ProfilerExample_logger.class);

      //Creating a profiler
      Profiler profiler = new Profiler("Sample");

      //Adding logger to the profiler
      profiler.setLogger(logger);

      //Starting a child stop watch and stopping the previous one.
      profiler.start("Task 1");
      obj.demoMethod1();

      //Starting another child stop watch and stopping the previous one.
      profiler.start("Task 2");
      obj.demoMethod2();

      //Stopping the current child watch and the global watch.
      TimeInstrument tm = profiler.stop();

      //Logging the contents of the time instrument
      tm.log();
   }
}

Production

Lors de l'exécution, le programme ci-dessus génère la sortie suivante.

Sum of squares of the numbers from 1 to 10000: 3.328335E8
Sum of the numbers from 1 to 10000: 49995000