Qu'est-ce que Logger en Java et pourquoi l'utilisez-vous?

Cet article sur Logger in Java est un guide complet sur l'API de journalisation Java utilisée pour les solutions de journalisation lors de la création de projets.

La journalisation est une fonctionnalité importante qui doit être prise en compte par les développeurs pour retracer les erreurs. , étant l'un des langages de programmation les plus populaires, est livré avec une approche personnalisable de la journalisation en fournissant une API de journalisation de base. Donc, dans cet article sur Logger en Java, je vais expliquer comment peut utiliser cette fonction pour activer la journalisation extensible en Java.



Les sujets suivants seront traités dans cet article:



    1. Besoin de journalisation
    2. Composants de journalisation
    3. Qu'est-ce que Logger?
    4. Appender ou gestionnaires
    5. Mise en page ou formateurs

Avant, nous approfondissons la connexion en java, comprenons la nécessité de la journalisation.

obtenir la date à partir de la chaîne java

Besoin de journalisation

Lors de la création d'applications, nous sommes souvent confrontés à des erreurs qui doivent être déboguées. Ainsi, à l'aide des journaux, nous pouvons facilement obtenir des informations sur ce qui se passe dans l'application avec un enregistrement des erreurs et des circonstances inhabituelles. Maintenant, vous pourriez penser que, pourquoi ne pas utiliser l'instruction System.out.print () dans . Eh bien, le problème avec ces instructions est que les messages du journal ne seront imprimés que sur la console. Ainsi, une fois que vous fermez la console, automatiquement, tous les journaux seront perdus. Par conséquent, les journaux ne seront pas stockés de manière permanente et sont affichés un par un, car il s'agit d'un environnement à thread unique.



Pour éviter de tels problèmes, la journalisation en Java est simplifiée à l'aide duAPI fournie via lejava.util.loggingpackage, et leorg.apache.log4j. *paquet.

Composants de journalisation

Les composants de journalisation Java aident le développeur à créer des journaux, à transmettre les journaux à la destination respective et à maintenir un format approprié. Voici les trois composants:

  • Enregistreurs - Responsable de capturer les enregistrements du journal et de les transmettre à l'appendeur correspondant.
  • Appenders ou gestionnaires - Ils sont responsables de l'enregistrement des événements du journal vers une destination. Les appenders mettent en forme les événements à l'aide de Layouts, avant d'envoyer les sorties.
  • Mises en page ou formateurs - Responsable de déterminer à quoi ressemblent les données lorsqu'elles apparaissent dans l'entrée de journal.

Vous pouvez vous référer à l'image ci-dessous pour le fonctionnement des trois composants:



Composants de journalisation - Logger en Java - Edureka

Lorsqu'une application effectue un appel de journalisation, le composant Logger enregistre l'événement dans un LogRecord et le transmet à l'appender approprié. Ensuite, il a formaté l'enregistrement en utilisant la mise en page selon le format requis. En dehors de cela, vous pouvez également utiliser plusieurs filtres pour spécifier les appenders à utiliser pour les événements.

Maintenant, comprenons ce qu'est un enregistreur en Java en profondeur.

Qu'est-ce que Logger en Java?

Les enregistreurs en Java sont des objets qui déclenchent des événements de journal.Ils sont créés et appelés dans le code de l'application, où ils génèrent des événements de journal avant de les transmettre au composant suivant qui est un Appender. Vous pouvez utiliser plusieurs enregistreurs dans une même classe pour répondre à divers événements ou utiliser des enregistreurs dans une hiérarchie. Ils sont normalement nommés à l'aide de l'espace de noms hiérarchique séparé par des points. En outre, tous les noms de Logger doivent être basés sur la classe ou le nom de package du composant journalisé.

En dehors de cela, chaque enregistreur garde une trace de l'ancêtre existant le plus proche dans le Journaux espace de noms et a également un «Niveau» qui lui est associé. Eh bien, je parlerai des enregistreurs dans la dernière partie de cet article, mais avant cela, laissez-moi vous montrer comment créer un enregistreur en Java.

Créer un nouvel enregistreur

Le processus de création d'un nouvel enregistreur en Java est assez simple. Vous devez utiliserLogger.getLogger ()méthode. LagetLogger () identifie le nom de l'enregistreur et prend la chaîne comme paramètre. Donc, si un enregistreur préexiste alors, cet enregistreur est renvoyé, sinon un nouvel enregistreur est créé.

Syntaxe:

enregistreur statique Logger = Logger.getLogger (SampleClass.class.getName ())

Ici, SampleClass est le nom de la classe pour laquelle nous obtenons l'objet Logger.

Exemple:

public class Customer {Private static final Logger LOGGER = Logger.getLogger (Customer.class) public void getCustomerDetails () {}}

Maintenant que je vous ai dit comment créer un Logger en Java, voyons les différents niveaux disponibles dans la journalisation.

Niveaux de journal

Les niveaux de journal sont utilisés pour classer les journaux en fonction de leur gravité ou de leur impact sur la stabilité de l'application. Laorg.apache.log4j. *package et lejava.util.loggingles deux fournissent différents niveaux de journalisation. Jetons un coup d'œil à chacun d'eux un par un.

org.apache.log4j. *package fournit les niveaux suivants dans l'ordre décroissant:

  • MORTEL
  • ERREUR
  • PRÉVENIR
  • INFO
  • DÉBOGUER

java.util.loggingpackage fournit les niveaux suivants dans l'ordre décroissant:

  • GRAVE (NIVEAU LE PLUS ÉLEVÉ)
  • ATTENTION
  • INFO
  • CONFIG
  • BIEN
  • PLUS FIN
  • FINEST (NIVEAU LE PLUS BAS)

En dehors de cela, le package ci-dessus fournit également deux niveaux supplémentairesTOUTetDEutilisé pour enregistrer tous les messages et désactiver la journalisation respectivement.

Exemple de journalisation en Java à l'aide duorg.apache.log4j. *paquet:

import org.apache.log4j.Logger public class Customer {static Logger logger = Logger.getLogger (Customer.class) public static void main (String [] args) {logger.error ('ERROR') logger.warn ('WARNING' ) logger.fatal ('FATAL') logger.debug ('DEBUG') logger.info ('INFO') System.out.println ('Final Output')}}

Donc, si votre sortie estroot logger comme niveau WARN dans notre log4j.properties fichier, alors tous les messages d'erreur avec une priorité plus élevée que WARN seront imprimés comme ci-dessous:

Vous pouvez également définir le niveau en utilisant la méthode setLevel () de lajava.util.loggingpaquet comme ci-dessous:

logger.setLevel (Level.WARNING)

Exemple de journalisation en Java à l'aide dujava.util.loggingpaquet:

package edureka import java.io.IOException import java.util.logging.Level import java.util.logging.Logger import java.util.logging. * class EdurekaLogger {privé final statique Logger LOGGER = Logger.getLogger (Logger.GLOBAL_LOGGER_NAME) public void sampleLog () {LOGGER.log (Level.WARNING, 'Welcome to Edureka!')}} public class Customer {public static void main (String [] args) {EdurekaLogger obj = new EdurekaLogger () obj.sampleLog () LogManager slg = LogManager.getLogManager () Logger log = slg.getLogger (Logger.GLOBAL_LOGGER_NAME) log.log (Level.WARNING, 'Salut! Bienvenue d'Edureka')}}

Pour activer la journalisation dans votre application à l'aide duorg.apache.log4j. *package ou lejava.util.loggingpackage, vous devez configurer le fichier de propriétés. Ensuite, dans cet article sur Logger en Java, parlons du fichier de propriétés des deux.

Fichier de propriétés du package Log4j et Java Util

Exemple de fichier de propriétés Log4j:

# Activer l'option d'enregistrement racine log4j.rootLogger = INFO, fichier, stdout # Joindre des appenders au fichier d'impression log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File = E: loglogging.log log4j.appender. file.MaxFileSize = 10 Mo log4j.appender.file.MaxBackupIndex = 5 log4j.appender.file.layout = org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern =% j {aaaa-MM-jj HH: mm : ss}% -5p% c {1}:% L -% m% n # Joindre des appenders à imprimer sur la console log4j.appender.stdout = org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target = System.out log4j.appender.stdout.layout = org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern =% d {aaaa-MM-jj HH: mm: ss}% -5p% c {1}:% L -% m% n
  • Le fichier de propriétés Log4j est créé dans le dossier src du projet.
  • log4j.appender.file = org.apache.log4j.RollingFileAppender -> Imprime tous les journaux dans un fichier
  • log4j.appender.stdout = org.apache.log4j.ConsoleAppender -> Imprime tous les journaux de la console
  • log4j.appender.file.File = D: loglogging.log -> Spécifie l'emplacement du fichier journal
  • log4j.appender.file.MaxFileSize = 10 Mo -> Taille maximale du fichier journal à 10 Mo
  • log4j.appender.file.MaxBackupIndex = 5 -> Limite le nombre de fichiers de sauvegarde à 5
  • log4j.appender.file.layout = org.apache.log4j.PatternLayout -> Spécifie le modèle dans lequel les journaux seront imprimés dans le fichier journal.
  • log4j.appender.file.layout.ConversionPattern =% d {aaaa-MM-jj HH: mm: ss}% -5p% c {1}:% L -% m% n -> Définit le modèle de conversion par défaut.

Échantillon Fichier de propriétés du package Java Util

handlers = java.util.logging.ConsoleHandler .level = WARNING # La sortie sera stockée dans le répertoire par défaut java.util.logging.FileHandler.pattern =% h / java% u.log java.util.logging.FileHandler.limit = 60000 java.util.logging.FileHandler.count = 1 java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter # Le niveau des journaux sera limité à WARNING et au-dessus. java.util.logging.ConsoleHandler.level = AVERTISSEMENT java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

Ici,

  • java.util.logging.FileHandler.pattern =% h / java% u.log -> Les fichiers journaux seraient écrits dansC: TEMPjava1.log
  • java.util.logging.FileHandler.limit = 50000 ->Quantité maximale que le journal écrit dans un fichier en octets.
  • java.util.logging.FileHandler.count = 1 -> Spécifie le nombre de fichiers de sortie
  • java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter -> Mentionne le formateur utilisé pour le formatage. Ici, XML Formatter est utilisé.
  • java.util.logging.ConsoleHandler.level = AVERTISSEMENT -> Définit le niveau de journalisation par défaut sur AVERTISSEMENT
  • java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter ->Spécifie leFormateurà utiliser par tousConsoleHandler«S. Ici, SimpleFormatter est utilisé.

Journalisation des événements

Pour enregistrer des événements , vous devez vous assurer que vous attribuez un niveau pour classer facilement les événements. Pour attribuer un niveau et mentionner un message, vous pouvez utiliser les méthodes ci-dessous:

Méthode 1:

logger.log (Level.INFO, «Afficher le message»)
Ici, le niveau est INFO et le message à imprimer est «Afficher le message».

Méthode 2:

logger.info («Afficher le message»)

Pour vous assurer que Logger en Java enregistre uniquement les événements qui sont au niveau ou au-dessus du niveau INFO, vous pouvez utiliser le setLevel () méthode discutée ci-dessus.

Maintenant que j'ai discuté de la façon d'utiliser Logger en Java, discutons du prochain composant de l'architecture Log4j, à savoir les Appenders.

Appender ou gestionnaires

L'Appender ou les Handlers sont responsables de l'enregistrement des événements du journal vers une destination. Chaque enregistreur a accès à plusieurs gestionnaires et reçoit le message du journal de l'enregistreur. Ensuite, les Appenders utilisent des Formatters ou des Layouts pour formater les événements et les envoyer à la destination correspondante.

Un Appender peut être désactivé à l'aide de la méthode setLevel (Level.OFF). Les deux gestionnaires les plus standard dujava.util.loggingle paquet sont les suivants:

comment installer eclipse ide
  • FileHandler: Écrire le message du journal dans un fichier
  • ConsoleHandler: Écrit le message du journal sur la console

Pour votre meilleure compréhension, j'ai expliqué quelques Appenders dans la section des propriétés.

Mise en page ou formateurs

La disposition des formateurs est utilisée pour formater et convertir les données dans un événement de journal.Les frameworks de journalisation fournissent des mises en page pour HTML, XML, Syslog, JSON, texte brut et autres journaux.

  1. SimpleFormatter : Génère des messages texte avec des informations de base.
  2. XMLFormatter : Génère un message XML pour le journal

Pour votre meilleure compréhension, j'ai expliqué quelques mises en page dans la section des propriétés.Avec cela, nous arrivons à la fin de ce blog sur «Logger in Java». J'espère que vous avez compris ce qui vous a été appris dans cet article.

Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Le cours de formation et de certification Java J2EE et SOA d'Edureka est conçu pour les étudiants et les professionnels qui souhaitent devenir développeur Java. Le cours est conçu pour vous donner une longueur d'avance dans la programmation Java et vous former aux concepts Java de base et avancés ainsi qu'à divers frameworks Java tels que Hibernate et Spring.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce blog «Logger in Java» et nous vous répondrons dans les plus brefs délais.