1.1 Introduction
C'est gênant de le dire. Récemment, la société a été envoyée à la société client pour interviewer des postes de développement externalisés. J'ai initialement préparé des questions d'entrevue connexes pour Redis, RabbitMQ, SSM Frameworks et quelques critiques de projet que j'avais faites. Je suis allé à l'interview avec confiance. En conséquence, quelqu'un a demandé quel était le système de journal utilisé dans le projet récent dès que je suis venu? Comment le niveau de journal est-il configuré? J'étais confus à ce moment-là. Je m'en occupe habituellement par le chef de projet. Je viens de fouiller sur Internet et je l'ai collé et c'était OK. Après avoir fini de parler, l'intervieweur m'a lancé un regard profond. À ce moment-là, j'avais honte ...
1.2 Parlez-moi moins de potins et racontez-moi l'histoire du développement du journal (si vous le savez déjà, vous pouvez le sauter et regarder la configuration du journal 1.3)
Pour avoir une compréhension approfondie de la mise en œuvre de la technologie des journaux, je recommande personnellement de lire: Logback + SLF4J. Quant à la configuration du journal, il est préférable de comprendre Log4j, car la plupart des projets utilisent actuellement LOG4J. D'accord, commençons par l'histoire de développement du journal:
En 1999, la communauté open source d'Apache a publié Log4J, qui a provoqué une sensation dans le monde du programme. Depuis lors, il est devenu la norme pour l'exploitation forestière et a été largement utilisé par les programmeurs Java. Plus tard, Sun a également publié le mécanisme de journalisation (java.util.logging, ci-après dénommé juil Bientôt, Apache a lancé le cadre du journal des communes-loging (qui permet aux développeurs de résumer les méthodes de mise en œuvre du journal sans prêter attention à quelle technologie de journal est utilisée. En termes simples, vous voulez appeler Didi sur votre téléphone mobile. Si vous êtes à Pékin, vous appellerez Didi à Pékin, et à Hong Kong, vous appellerez Didi depuis Hong Kong). Ce cadre semble être un mépris pour le soleil. Il peut trouver et appeler automatiquement la technologie du journal dans l'environnement actuel pour la sortie du journal. Le Framework journal peut prendre en charge LOG4J ou Jul. Commons-Logging + Log4J est devenu une combinaison classique de journaux Java pendant longtemps après cela. Cependant, les communes-loging n'ont pas été mis à jour depuis un certain temps. Je me demande si la conception des communes-loging n'était pas assez bonne, et il est plus difficile de l'optimiser. Pourquoi dites-vous cela? Parce que l'excellent cadre d'excellente journalisation SLF4J est né, l'auteur (Ceki Gülcü) est l'un des auteurs de Log4J. Son SLF4J est plus élégant dans la conception, et il a également implémenté la technologie de journalisation, qui est également plus de pointe que Log4J. À ce stade, la situation où le système de journal est dominé par les communes-loging + log4j a commencé à être secoué, et divers communes-loging + log4j? slf4j + log4j? SLF4J + Logback? La combinaison est vraiment déchirante. Ce qui est encore plus terrifiant, c'est que le patron de Ceki Gülcü a aidé à optimiser Log4J, et depuis lors, il y a eu une autre technologie de journalisation dans le monde - Log4J2. Est-ce que cela va apprendre de Tencent pour faire WeChat et QQ? C'est vraiment 666. Par conséquent, si vous voulez avoir une compréhension approfondie de la technologie de journalisation, vous pouvez trouver des informations pertinentes sur Logback + SLF4J. Quant au fichier de configuration, je pense que vous pouvez simplement comprendre l'explication détaillée de la configuration log4j que j'ai écrite ci-dessous. Après tout, de nombreuses entreprises utilisent désormais le cadre log4j.
1.3 Aller au sujet, configuration de journal de base
1. Créez un nouveau fichier log4j.properties dans le cadre du package ClassPath ou Resource (projet Maven). Les paramètres suivants sont suffisants pour la configuration initiale du projet. Pour une configuration plus détaillée,
Continuez à afficher la configuration du niveau du log4j 1.4;
# Spécifier le niveau de journal et la source de sortie via le journaliste racine #La priorité de la sortie du journal: debug <info <warn <error <Fatal # définir le niveau de journal (info) du journal racine et l'alias de la source de sortie (console, myfile) # cette définition implementation of the output source console as console output##########Define the output source alias console (that is, the output source defined by the root logger)# The implementation class is ConsoleAppender (console output source) log4j.appender.console=org.apache.log4j.ConsoleAppender #The format converter for specifying the log output format is the PatternLayout implementation class LOG4J.APPENDER.CONSOLE.LAYOUT = ORG.APACHE.LOG4J.PATTERNLAYOUT # Définissez le format spécifique de la sortie du journal log4j.appender.console.layout.conversionpattern =% d% -5p [% c.% m ()] -% m% n ###### ## Configurer la source de sortie MyFile Implémentation spécifique comme fichier Sortie ######### alias myfile (c'est-à-dire la source de sortie définie par le journaliste root) # La classe d'implémentation est rollingFileAppender (Source de sortie du fichier) log4j.appendender.myfile = org.apache.log4j.rollingFileAppender # Définir le chemin de stock Le fichier journal log4j.appenden log4j.appender.myfile.layout = org.apache.log4j.patternlayout # définir le format spécifique de la sortie du journal log4j.appender.console.layout.conversionpattern =% d% -5p [% c.% m ()] -% m% n ####### # # # # # # ## ## ###### # # # # # #### # ## ###### # # # # # # # # # # # # # # # # # # ###### # # # # # # Le format est ISO8601 et le format peut également être spécifié. #Definition est le suivant:% d {yyy année mm mois dd jour hh hh hh mm minute ss seconds sss}, et la sortie sera: #januar est à droite), vous pouvez en apprendre un exemple #% C: le nom complet de la classe où le journal est situé #% m: le nom de la méthode où le journal est situé #% M: Informations de journal #% n: Sortie une ligne de retour de chariot Break #% L: Numéro de ligne de sortie dans le code2. Call journal pour tester les résultats de la configuration.
import org.apache.log4j.logmanager; import org.apache.log4j.logger; import org.apache.log4j.propertyconfigurator; public class logpropernest {public static void main (string [] args) {/ * parin de configuration des fichiers de configuration sous la chaîne non classcat log4jpath = system.getProperty ("user.dir") + "// src // log // logproperties // log4j.properties"; PropertyConfigurator.Configure (log4jpath); * / logger log = logManager.getLogger (logProperStist.class); log.debug ("débogage"); log.info ("information"); log.warn ("avertissement"); log.Error ("erreur"); log.fatal ("erreur fatale"); }}1.4 Configuration du niveau du journal
La configuration du niveau de journal peut être divisée en trois catégories. La configuration ci-dessus consiste à configurer le niveau de journal du journaliste parent, la deuxième catégorie consiste à configurer le niveau de journal du journal de sous-classe, et la troisième catégorie consiste à configurer le niveau de journal de la source de sortie (console, fichier, etc.). Leur priorité d'analyse de niveau logarithmique est organisée de faible à haut. Je suis désolé de ne pas avoir expliqué clairement la déclaration spécifique. Je devrais être en mesure de comprendre directement le cas!
1. Si le niveau de journal du journaliste parent (RootLogger) (en supposant qu'il s'agit du niveau d'informations), le niveau de journal du journaliste de sous-classe n'est pas configuré et le niveau de journal de la source de sortie n'est pas configuré, la source de sortie ne peut que le niveau d'informations de sortie ou supérieur;
2. Si le niveau de journal du journaliste parent (RootLogger) (en supposant qu'il s'agit d'un niveau d'information), le niveau de journal du journal de sous-classe (en supposant qu'il est de débogage) et le niveau de journal de la source de sortie n'est pas configuré, la sortie de la source de sortie est supérieure au niveau de débogage;
3. Si le niveau de journal du journaliste parent (RootLogger) (en supposant qu'il s'agit du niveau d'informations), le niveau de journal du journal de sous-classe (en supposant qu'il s'agit du niveau de débogage), et le niveau de journal de la source de sortie (en supposant qu'il s'agit du niveau d'information), la source de sortie sortira un niveau d'informations ou supérieur;
4. Si le niveau de journal du journal parent (RootLogger) (en supposant qu'il s'agit du niveau d'informations), le niveau de journal du journaliste de sous-classe n'est pas configuré et le niveau de journal du journaliste de sous-classe est configuré.
Le niveau de journal de la source de sortie (en supposant qu'il s'agit du niveau de débogage), puis la source de sortie sortira un niveau d'information ou supérieur;
Par conséquent, dans le cas ci-dessus, nous pouvons savoir qu'il existe 2 relations logiques entre le journal de la source et le niveau de journal de sortie de la source de sortie:
1. Si la source de sortie ne définit pas le niveau de journal, il héritera le niveau de journal le plus proche de son enregistreur de sous-classe; Si le journal de sous-classe ne définit pas le niveau de journal, il héritera de l'enregistreur parent le plus proche de son enregistreur parent.
2. Lors de l'impression du journal, la source de sortie se comparera au niveau de journal défini par le journal de sous-classe qui est le plus proche de lui. Si le niveau défini par la source de sortie est supérieur à la bûcheron de sous-classe, le journal sera sorti en fonction du niveau de journal défini par la source de sortie, et vice versa.
Par conséquent, dans le projet, vous pouvez configurer le niveau de journal en fonction de la méthode de configuration quotidienne:
#Control Le niveau de journal du journaliste parent est des informations. Par défaut, seuls les journaux au-dessus du niveau d'informations sont sortis dans tous les modules log4j.rootlogger = info, console # console # Contrôlez le niveau de journal d'un module séparément à l'erreur, et les journaux sont sortis uniquement lorsqu'une exception se produit log4j.logger.log.logProperties = erreur # # Contrôler le niveau de journal d'une classe séparément à débogage, confiant à la sortie des informations débogue log4j.logger.log.logproperties.logProperStistEst = Debug ################################################### ################################################################################################################################## ################################################################################################################################# ################################################################################################################################## # Spécifier le niveau de journal de la source de sortie actuelle. Avec la configuration précédente, vous n'avez pas besoin de configurer cet élément # log4j.appender.console.thershold = info # Spécifiez le format de la sortie du journal: format flexible log4j.appender.console.layout = org.apache.log4j.patternlayout #Content de format spécifique Log4j.Aptend.ConSolet.Conversation #ContentTat [% c.% m ()] -% m% n
1.5 Conclusion
À ce stade, je crois que vous avez une compréhension de base de la configuration du journal. Il y a beaucoup de choses dans l'article qui peuvent être fausses, et tous les héros sont les bienvenus pour les signaler. J'ai écrit un article pour le résumer afin de pouvoir comprendre profondément la configuration de cette technologie, afin que j'en ai une compréhension plus approfondie.