1.1 Introduction aux journaux
Le journal est une liste des événements qui se sont produits. Presque comme un journal ou un journal nautique. Eh bien, en conséquence, un enregistreur est un objet avec lequel vous pouvez vous connecter. En programmation, il est d'usage de loguer presque tout. Et à Java, tout est comme ça et même un peu plus.
Le fait est que les programmes Java sont très souvent de grandes applications serveur sans interface utilisateur, console, etc. Ils traitent les demandes de milliers d'utilisateurs en même temps et souvent diverses erreurs se produisent. Surtout lorsque différents threads commencent à interférer les uns avec les autres.
Et, en fait, la seule façon de trouver des erreurs et des échecs rarement reproduits dans une telle situation est d' écrire dans le journal / fichier tout ce qui se passe dans chaque thread.
Le plus souvent, des informations sont écrites dans le journal sur les paramètres de la méthode avec laquelle elle a été appelée, toutes les erreurs interceptées et de nombreuses informations intermédiaires. Plus le journal est complet, plus il est facile de restituer la séquence des événements et de retracer les causes d'une panne ou d'une erreur.
Mais plus la bûche est grande, plus il est difficile de travailler avec. Parfois, les journaux atteignent plusieurs gigaoctets par jour. C'est bon.
1.2 Échec des journaux
Comme les premiers journaux, les développeurs utilisaient simplement la sortie vers la console . Il est pratique de le faire pendant le débogage de l'application - lorsque toutes les informations importantes et les valeurs variables sont écrites sur la console. Mais un tel journal est totalement inapplicable lors du fonctionnement normal de l'application.
Premièrement, l'application peut vouloir sortir quelque chose sur la console elle-même, et l'utilisateur ne veut pas du tout voir les informations de service destinées au programmeur.
Deuxièmement, la taille du tampon de la console est limitée, vous ne pouvez pas y écrire grand-chose.
Et enfin, troisièmement, les informations sur les erreurs de programme collectées sur une longue période de temps doivent être envoyées aux développeurs de programmes. Et il est plus pratique d'écrire toutes ces informations en même temps dans un fichier.
Les développeurs ont rapidement résolu le premier problème - ils ont proposé un autre flux de sortie - System.err. Vous pouvez y écrire des messages et ils seront envoyés à un thread séparé, et non à la console standard.
Et même le problème d'écriture dans un fichier a été résolu :
// Define the file to which we will write the log
System.setErr(new PrintStream(new File("log.txt")));
// Display messages
System.err.println("Message 1");
System.err.println("Message 2");
// Display an error message
try {
throw new Exception("Error message");
} catch (Exception e) {
e.printStackTrace();
}Mais même sous cette forme, cela ne résolvait pas tout le problème, il a donc été décidé de créer une bibliothèque spéciale qui écrirait des messages de journal dans un fichier. Elle l'a fait de manière intelligente et a permis la flexibilité de configurer des filtres pour les événements et les données enregistrés.
L'ensemble du processus de journalisation, en fait, se compose de trois parties :
- La première partie est la collecte d'informations .
- La deuxième partie est le filtrage des informations collectées.
- La troisième partie est l'enregistrement des informations sélectionnées.
1.3 Introduction à l'enregistreur log4j
Le premier enregistreur populaire dans la communauté Java était le log4j. L'inclure dans le projet est très simple, pour cela, vous n'avez qu'à ajouter quelques lignes à votre pom.xml
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>2.2.17</version>
</dependency>L'interaction de votre programme avec un tel enregistreur ressemblerait à ceci :
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}Trois choses se passent ici :
La création de l'objet est surlignée en vert Logger . Son objet est stocké dans une variable statique pour un travail ultérieur pratique avec lui. De plus, getLogger()des informations sur la classe dans laquelle les informations sont collectées sont transmises à la méthode.
La ligne surlignée en bleu est l'endroit où nous enregistrons les informations de valeur uniquement pendant le débogage . Pour cela, une méthode spéciale est utilisée -debug()
Et enfin, la ligne où nous enregistrons l'exception survenue dans le journal est surlignée en rouge . Les exceptions sont des erreurs potentielles, donc le fichier error().