Dans ce tutoriel, nous allons en apprendre davantage sur Java Logging et ses différents composants à l'aide d'exemples.
Java nous permet de créer et de capturer des messages et des fichiers journaux via le processus de journalisation.
En Java, la journalisation nécessite des frameworks et des API. Java a un cadre de journalisation java.util.loggingintégré dans le package.
Nous pouvons également utiliser des frameworks tiers tels que Log4j, Logback et bien d'autres à des fins de journalisation.
Composants de journalisation Java
La figure ci-dessous représente les composants principaux et le flux de contrôle de l'API Java Logging ( java.util.logging).
Journalisation Java
1. Enregistreur
La Loggerclasse fournit des méthodes de journalisation. Nous pouvons instancier des objets de la Loggerclasse et appeler ses méthodes à des fins de journalisation.
Prenons un exemple.
Logger logger = Logger.getLogger("newLoggerName");
La getLogger()méthode de la Loggerclasse est utilisée pour trouver ou créer un nouveau Logger. L'argument chaîne définit le nom de l'enregistreur.
Ici, cela crée un nouvel Loggerobjet ou renvoie un existant Loggeravec le même nom.
C'est une convention pour définir un Loggeraprès la classe courante en utilisant class.getName().
Logger logger = Logger.getLogger(MyClass.class.getName());
Remarque: Cette méthode lancera NullPointerExceptionsi le nom passé est null.
Chacun Loggera un niveau qui détermine l'importance du message du journal. Il existe 7 niveaux de journalisation de base:
| Niveau de journal (par ordre décroissant) | Utilisation |
|---|---|
| SÉVÈRE | échec grave |
| ATTENTION | message d'avertissement, un problème potentiel |
| INFO | informations générales d'exécution |
| CONFIG | informations de configuration |
| BIEN | informations générales pour les développeurs (suivi des messages) |
| PLUS FIN | informations détaillées sur le développeur (messages de traçage) |
| FINEST | informations de développeur très détaillées (suivi des messages) |
| DE | désactiver la journalisation pour tous les niveaux (ne rien capturer) |
| TOUT | activer la journalisation pour tous les niveaux (tout capturer) |
Chaque niveau de journal a une valeur entière qui détermine leur gravité, à l'exception de deux niveaux de journal spéciaux OFFet ALL.
Enregistrer le message
Par défaut, les trois premiers niveaux de journalisation sont toujours enregistrés. Pour définir un niveau différent, nous pouvons utiliser le code suivant:
logger.setLevel(Level.LogLevel); // example logger.setLevel(Level.FINE);
Dans cet exemple, seuls le niveau FINEet les niveaux supérieurs sont définis pour être enregistrés. Tous les autres messages du journal sont supprimés.
Maintenant, pour enregistrer un message, nous utilisons la log()méthode.
logger.log(Level.LogLevel, "log message"); // example logger.log(Level.INFO, "This is INFO log level message");
Il existe des méthodes abrégées pour la journalisation aux niveaux souhaités.
logger.info( "This is INFO log level message"); logger.warning( "This is WARNING log level message");
Toutes les demandes de journal qui ont passé le niveau de journalisation défini sont ensuite transmises au LogRecord .
Remarque: Si le niveau d'un enregistreur est défini sur null, son niveau est hérité de son parent et ainsi de suite dans l'arborescence.
2. Filtres
Un filtre (s'il est présent) détermine si le LogRecord doit être transmis ou non. Comme son nom l'indique, il filtre les messages du journal selon des critères spécifiques.
Un LogRecord n'est transmis du logger au gestionnaire de journal et du gestionnaire de journal aux systèmes externes que s'il passe les critères spécifiés.
// set a filter logger.setFilter(filter); // get a filter Filter filter = logger.getFilter();
3. Gestionnaires (Appenders)
Le gestionnaire de journal ou les appenders reçoivent le LogRecord et l'exporte vers diverses cibles.
Java SE fournit 5 gestionnaires intégrés:
| Manutentionnaires | Utilisation |
|---|---|
StreamHandler | écrit dans un OutputStream |
ConsoleHandler | écrit dans la console |
FileHandler | écrit dans un fichier |
SocketHandler | écrit sur les ports TCP distants |
MemoryHandler | écrit en mémoire |
Un gestionnaire peut transmettre le LogRecord à un filtre pour déterminer à nouveau s'il peut être transmis à des systèmes externes ou non.
Pour ajouter un nouveau gestionnaire, nous utilisons le code suivant:
logger.addHandler(handler); // example Handler handler = new ConsoleHandler(); logger.addHandler(handler);
Pour supprimer un gestionnaire, nous utilisons le code suivant:
logger.removeHandler(handler); // example Handler handler = new ConsoleHandler(); logger.addHandler(handler); logger.removeHandler(handler);
Un enregistreur peut avoir plusieurs gestionnaires. Pour obtenir tous les gestionnaires, nous utilisons le code suivant:
Handler() handlers = logger.getHandlers();
4. Formateurs
Un gestionnaire peut également utiliser un formateur pour mettre en forme l' objet LogRecord en une chaîne avant de l'exporter vers des systèmes externes.
Java SE a deux formateurs intégrés :
| Formateurs | Utilisation |
|---|---|
SimpleFormatter | formate LogRecord en chaîne |
XMLFormatter | formate LogRecord au format XML |
Nous pouvons utiliser le code suivant pour formater un gestionnaire:
// formats to string form handler.setFormatter(new SimpleFormatter()); // formats to XML form handler.setFormatter(new XMLFormatter());
LogManager
L' objet LogManager assure le suivi des informations de journalisation globales. Il lit et maintient la configuration de journalisation et les instances de journalisation.
Le gestionnaire de journaux est un singleton, ce qui signifie qu'une seule instance de celui-ci est instanciée.
Pour obtenir l'instance du gestionnaire de journaux, nous utilisons le code suivant:
LogManager manager = new LogManager();
Avantages de la journalisation
Voici quelques-uns des avantages de la journalisation en Java.
- aide à surveiller le déroulement du programme
- aide à capturer les erreurs qui peuvent survenir
- fournit une assistance pour le diagnostic et le débogage des problèmes
