Journalisation Java
Journalisation Java
Dans ce didacticiel, nous allons découvrir 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 de journal tout au long du processus de journalisation.
En Java, la journalisation nécessite des frameworks et des API. Java a un cadre de journalisation intégré dans le java.util.logging paquet.
Nous pouvons également utiliser des infrastructures tierces telles que Log4j, Logback et bien d'autres à des fins de journalisation.
Composants de journalisation Java
La figure ci-dessous représente les composants de base et le flux de contrôle de l'API Java Logging (java.util.logging ).
1. Enregistreur
Le Logger La classe fournit des méthodes de journalisation. Nous pouvons instancier des objets à partir du Logger classe et appelez ses méthodes à des fins de journalisation.
Prenons un exemple.
Logger logger = Logger.getLogger("newLoggerName");
Le getLogger() méthode du Logger class est utilisé pour trouver ou créer un nouveau Logger . L'argument de chaîne définit le nom de l'enregistreur.
Ici, cela crée un nouveau Logger objet ou retourne un Logger existant avec le même nom.
C'est une convention de définir un Logger après la classe actuelle en utilisant class.getName() .
Logger logger = Logger.getLogger(MyClass.class.getName());
Remarque : Cette méthode lancera NullPointerException si le nom passé est null .
Chaque Logger a un niveau qui détermine l'importance du message de journal. Il existe 7 niveaux de journal de base :
| Niveau de journalisation (par ordre décroissant) | Utiliser |
|---|---|
| SÉVÈRE | panne grave |
| AVERTISSEMENT | message d'avertissement, problème potentiel |
| INFO | informations générales sur l'exécution |
| CONFIG | informations de configuration |
| BIEN | informations générales pour les développeurs (messages de suivi) |
| PLUS FIN | informations détaillées sur le développeur (messages de suivi) |
| FINEST | informations de développeur très détaillées (messages de suivi) |
| OFF | désactiver la journalisation pour tous les niveaux (ne rien capturer) |
| TOUS | activer la journalisation pour tous les niveaux (tout capturer) |
Chaque niveau de journal a une valeur entière qui détermine sa gravité, à l'exception de deux niveaux de journal spéciaux OFF et ALL .
Journaliser le message
Par défaut, les trois premiers niveaux de journalisation sont toujours consigné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, seul le niveau FINE et les niveaux supérieurs sont configurés pour être enregistrés. Tous les autres messages du journal sont supprimés.
Maintenant, pour enregistrer un message, nous utilisons le 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 dépassé le niveau de journal 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 enregistrement de journal n'est transmis de l'enregistreur au gestionnaire de journaux et du gestionnaire de journaux aux systèmes externes que s'il satisfait aux critères spécifiés.
// set a filter
logger.setFilter(filter);
// get a filter
Filter filter = logger.getFilter();
3. Gestionnaires (Appendeurs)
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 :
| Gestionnaires | Utiliser |
|---|---|
StreamHandler | écrit dans un OutputStream |
ConsoleHandler | écrit sur la console |
FileHandler | écrit dans le fichier |
SocketHandler | écrit sur des ports TCP distants |
MemoryHandler | écrit en mémoire |
Un gestionnaire peut passer 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 logger 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 Formatter pour formater le LogRecord objet dans une chaîne avant de l'exporter vers des systèmes externes.
Java SE dispose de deux formateurs intégrés :
| Formateurs | Utiliser |
|---|---|
SimpleFormatter | formate LogRecord enchaîner |
XMLFormatter | formate LogRecord au formulaire 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());
Gestionnaire de journaux
Le LogManager L'objet garde une trace 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 toutes les erreurs susceptibles de se produire
- fournit une assistance pour le diagnostic des problèmes et le débogage
Java