Configuration simple

#指定logger
# 配置Logger组件 
# 设定Log4j的日志级别(error warn info  debug)
# 输出目的地(Console, logfile是appender的名字,是自己定义的,后面才赋予具体的含义)
log4j.rootLogger=debug, Console, logfile
###################################################################################################################
#指定appender(目的地)
#设定Logger的Console(appender的名字)的Appender类型为控制台输出
#org.apache.log4j.ConsoleAppender 表明 Console是控制台输出
log4j.appender.Console=org.apache.log4j.ConsoleAppender

#输出的格式
#设定Console的Appender布局Layout
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式）包含选项：
#                     ConversionPattern=%m%n :指定怎样格式化指定的消息
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
#2009-09-29 07:30:43,265 INFO com.itcast.web.controller.SearchCdServlet.doGet() - e
log4j.appender.Console.layout.ConversionPattern=%d %p %c.%M() - %m%n

###################################################################################################################
#设定Logger的logfile(appender的名字)的Appender类型为文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.logfile=org.apache.log4j.RollingFileAppender

#设定文件的输出路径(指定文件的名字和路径,tomcat的启动路径)
log4j.appender.logfile.File=../logs/logstrore.log

#设定后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时,将会自动滚动,即将原来的内容移到logstrore.log.1文件
log4j.appender.logfile.MaxFileSize=2048KB

#Keep three backup files.指定可以产生的滚动文件的最大数
log4j.appender.logfile.MaxBackupIndex=4#设定logfile的Appender布局Layout
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p %c.%M() - %m%n
###################################################################################################################

Copier après la connexion

Log4JIntroduction

Log4J est un projet open source d'Apache. Il s'agit d'un package d'opérations de journalisation. En utilisant Log4J, vous pouvez spécifier la destination de la sortie des informations de journal, telles que la console, le fichier, le composant CUI, l'enregistreur d'événements NT. ; vous pouvez également contrôler le format de sortie de chaque journal. De plus, en définissant le niveau d'informations du journal, la sortie du journal peut être contrôlée de manière très détaillée. Le plus intéressant est que ces fonctions peuvent être configurées de manière flexible via un fichier de configuration sans modifier le code de l'application.

La sortie des journaux dans les applications a trois objectifs :

l Surveiller les modifications des variables dans le code et enregistrer périodiquement les données dans des fichiers pour une analyse statistique par d'autres applications

l Suivre les trajectoire d'exécution du code comme base pour les audits futurs

l Agir en tant que débogueur dans l'environnement de développement intégré, en imprimant les informations de débogage du code sur les fichiers et les consoles

Obligatoire Le moyen le plus courant de générer des journaux dans un Le programme consiste à intégrer des instructions dans le code. Ces instructions d'impression peuvent afficher les journaux sur la console ou dans un fichier. Une meilleure façon consiste à construire une classe d'opérations de journalisation pour encapsuler de telles opérations au lieu de laisser une série d'instructions d'impression remplir le corps du code. code.

Dans l'accent mis aujourd'hui sur les composants réutilisables, en plus de développer un nom de classe d'opération de journalisation réutilisable du début à la fin, Apache nous fournit un puissant journal prêt à l'emploi paquet d'opérations Log4J.

Log4J est principalement composé de trois composants principaux :

l Logger : responsable de la génération des journaux et de la capacité de classer et de filtrer les informations des journaux. En termes simples, il s'agit de décider quelles informations des journaux doivent être utilisées. être sorties et quelles informations de journal doivent être ignorées

l Appender : définit la destination de sortie des informations de journal et spécifie où les informations de journal doivent être sorties. Ces endroits peuvent être des consoles, des fichiers, des périphériques réseau, etc.

l Disposition : Spécifiez le format de sortie des informations du journal

Ces trois composants fonctionnent ensemble pour permettre aux développeurs d'enregistrer des informations en fonction des catégories d'informations du journal et de contrôler le format de sortie des informations du journal et le stockage des journaux. emplacement pendant l’exécution du programme.

Un enregistreur peut avoir plusieurs appenders, ce qui signifie que les informations du journal peuvent être sorties sur plusieurs appareils en même temps. Chaque appender correspond à une mise en page, et la mise en page détermine le format des informations du journal de sortie.

Supposons qu'en fonction des besoins réels, les informations du journal dans le programme doivent être sorties vers la console sur laquelle le programme est en cours d'exécution, et vers un fichier spécifié, et lorsque les informations du journal sont sorties vers la console, Disposition SimplLayout, lorsque la disposition PatternLayout lorsque les informations du journal sont sorties dans un fichier, la relation entre les trois composants Logger, Appender et Layout est comme indiqué dans la figure

<.>

Composant Appender (préciser l'objectif de sortie)

Le composant Appender de Log4J détermine où sortir les informations du journal. Récemment, l'Ａppeｽｎｽｒ de Log4J prend en charge les objectifs suivants :
l

Console (Console)

Fichier

ＧＵＩComponent

Un enregistreur peut correspondre à plusieurs appenders en même temps, c'est-à-dire que les informations de journal d'un enregistreur peuvent être sorties vers plusieurs destinations en même temps. : pour configurer le rootLogger Two Appenders ; l'un est un fichier et l'autre est une console, vous pouvez utiliser le code de configuration suivant :

log4j.rootLogger =WARN,file,console rootLogger Configurer le niveau de journalisation et l'objectif de sortie ;

log4j.rootLogger =WARN,file,console rootLogger 配置日志级别、输出目的；

log4j.appender.file=org.apache.log4jRollingFileAppender
log4j.appender.file=log.txt

log4j.appender.console=org.apache.log4j.ConsoleAppender

log4j.appender.file=org.apache.log4jRollingFileAppender Log4j.appender.file=log.txtlog4j.appender.console=org.apache.log4j.ConsoleAppender

Composant Layout
Le composant Layout est utilisé pour déterminer le format de sortie du journal. Il a les types suivants

l org.apache.log4j. .HTMLLayout (Mise en page au format de tableau HTML)

l org.apache.log4j.PatternLayout (le mode de mise en page peut être spécifié de manière flexible)

l org.apache.log4j.SimpleLayout (contient des informations de journal niveau et chaîne d'informations)

l org.apache.log4j.TTCCLayout (contient l'heure de génération du journal, les informations sur le fil de discussion et la catégorie)

Log4j Basic utilisation

Pour utiliser Log4J dans une application, configurez d'abord chaque composant de Log4j dans un fichier de configuration, puis vous pourrez faire fonctionner le journal via l'API Log4Ｊ dans le programme

Définir le fichier de configuration
Log4J se compose de trois composants importants : Logger, Appender et layout. Log4J prend en charge la configuration de ces composants par programme dans le programme, ainsi que la configuration des composants via des fichiers de configuration. Cette dernière méthode est plus flexible.

Log4J prend en charge deux formats de fichier de configuration, l'un est le format XML et l'autre est le fichier de propriétés Java,

1 Configurer le composant Logger La syntaxe est :

log4j.rootLogger = [ niveau ], appenderName1, appenderName2, …

Exemple :

log4j.rootLogger =WARN,file,console

niveau : est la priorité de la journalisation, divisée en OFF, FATAL, ERROR, WARN, INFO, DEBUG, ALL ou le niveau que vous définissez.

Log4j recommande d'utiliser seulement quatre niveaux. Les priorités de haut en bas sont ERREUR>WARN>INFO>DEBUG. Grâce aux niveaux définis ici, vous pouvez contrôler l'activation et la désactivation du niveau correspondant d'informations de journal dans l'application. Par exemple, réservez-le ici Si le niveau INFO est défini, toutes les informations du journal de niveau DEBUG dans l’application ne seront pas imprimées.

appenderName : spécifie où les informations du journal sont sorties. Vous pouvez spécifier plusieurs destinations de sortie en même temps.

Tous : imprime tous les journaux.

Désactivé : fermez tous les journaux.

Par exemple : log4j.rootLogger=info,A1,B2,C3

ConfigurationAppender Composant

La syntaxe est :

log4j.appender.appenderName =nom.entièrement.qualifié.de.appender.class.

Exemple :

log4j.appender.console=org.apache.log4j .ConsoleAppender

"fully.qualified.name.of.appender.class"
peut spécifier l'une des cinq destinations suivantes :
1.org.apache.log4j.ConsoleAppender(Console)
2.org.apache.log4j.FileAppender(Fichier)[Le journal ne peut être sorti que dans un seul fichier, non recommandé]
3.org.apache.log4j.DailyRollingFileAppender(génère un fichier journal chaque jour)
4.org.apache.log4j.RollingFileAppender (Générer un nouveau fichier lorsque la taille du fichier atteint la taille spécifiée)
5.org.apache.log4j.WriterAppender (Envoyer les informations du journal à n'importe quel endroit spécifié au format streaming)

ConsoleAppenderOptions Threshold=WARN : Spécifiez le niveau le plus bas de sortie des messages de journal. ImmediateFlush=true : La valeur par défaut est true, ce qui signifie que tous les messages seront affichés immédiatement.
Target=System.err : Par défaut : System.out, spécifiez la console de sortie

B
.FileAppender Options Threshold=WARN : Spécifie le niveau le plus bas de sortie des messages de journal.

ImmediateFlush=true : La valeur par défaut est true, ce qui signifie que tous les messages seront affichés immédiatement.

File=mylog.txt : Spécifiez le message à afficher dans le fichier mylog.txt.
Append=false : La valeur par défaut est true, ce qui signifie que le message sera ajouté au fichier spécifié. False signifie que le message écrasera le contenu du fichier spécifié par

.
C.DailyRollingFileAppenderOptions
Threshold=WARN : Spécifiez le niveau le plus bas de sortie des messages de journal.
ImmediateFlush=true : La valeur par défaut est true, ce qui signifie que tous les messages seront affichés immédiatement.
File=mylog.txt : Spécifiez le message à afficher dans le fichier mylog.txt.
Append=false : La valeur par défaut est true, ce qui signifie que le message sera ajouté au fichier spécifié. False signifie que le message écrasera le contenu du fichier

spécifié.
DatePattern='.'yyyy-ww : lancez le fichier une fois par semaine, c'est-à-dire générez un nouveau fichier chaque semaine. Bien entendu, vous pouvez également

préciser les mois, les semaines, les jours, les heures et les minutes. Autrement dit, le format correspondant est le suivant :
1)'.'aaaa-MM : Chaque mois
2)'.'aaaa-ww : chaque semaine
3)'.'aaaa-MM-jj : Tous les jours
4)'.'aaaa-MM-jj-a : deux fois par jour
5)'.'aaaa-MM-jj-HH : Toutes les heures
6)'.'aaaa-MM-jj-HH-mm : Chaque minute
D.RollingFileAppender Options
Seuil=WARN : Spécifier Le niveau le plus bas de sortie des messages de journal.
ImmediateFlush=true : La valeur par défaut est true, ce qui signifie que tous les messages seront affichés immédiatement.
File=mylog.log : Spécifiez le message à afficher dans le fichier mylog.txt.
Append=false : La valeur par défaut est true, ce qui signifie que le message sera ajouté au fichier spécifié, false signifie que le message écrasera le contenu du fichier spécifié

.
MaxFileSize=100 Ko : Le suffixe peut être Ko, Mo ou Go. Lorsque le fichier journal atteint la taille

, il défilera automatiquement, c'est-à-dire que le contenu original sera déplacé vers le fichier mylog.log.1.
MaxBackupIndex=2 : Spécifie le nombre maximum de fichiers glissants pouvant être générés.

3, configurez le format des informations du journal

La syntaxe est :
　1) log4j .appender.appenderName.layout=fully.qualified.name.of.layout.class
"fully.qualified.name.of.layout.class" peut être spécifié comme suitUn des 4 formats :

Exemple : log4j.appender.console.layout=org.apache.log4j.PatternLayout

log4j.appender.console.layout.ConversionPattern=%d %p %c.%M()-%m%n

1.org.apache.log4j.HTMLLayout (mise en page au format de tableau HTML) inclut les options :

LocationInfo=true : la valeur par défaut est false, affiche le nom du fichier Java et le numéro de ligne
Titre = mon fichier d'application : la valeur par défaut est Log4J Log Messages.

　 2.org.apache.log4j.PatternLayout (peut spécifier de manière flexible des modèles de mise en page) contient des options :

Modèle de conversion=%m%n :Spécifiez comment formater le message spécifié.

3.org.apache.log4j.SimpleLayout (contient le niveau et la chaîne d'informations des informations du journal)
　 4.org.apache.log4j.TTCCLayout (y compris le temps de génération du journal, le fil de discussion, la catégorie et d'autres informations)
%-5p %d{aaaa-MM-jj HH:mm:ssS} %c %m%n
La signification de plusieurs symboles dans le format d'informations du journal : 　-Numéro X : Les informations X sont alignées à gauche lors de la sortie ; %p : priorité des informations du journal de sortie, c'est-à-dire DEBUG, INFO, WARN, ERROR, FATAL,
%d : La date ou l'heure du point temporel du journal de sortie, le format par défaut est ISO8601, vous pouvez également spécifier le format par la suite, par exemple : %d{aaa MMM dd HH:mm:ss,SSS}, la sortie est similaire : 18 octobre , 2002 22:10:28,921%r: Afficher le nombre de millisecondes nécessaires entre le démarrage de l'application et la sortie des informations du journal
%c : Afficher la catégorie à laquelle appartiennent les informations du journal, généralement le nom complet de la classe
%t : Afficher le nom du thread qui a généré l'événement de journal
%l : affiche l'emplacement où l'événement de journal s'est produit, équivalent à la combinaison de %C.%M (%F:%L), y compris le nom de la catégorie et le fil de discussion où il s'est produit, et le nombre de lignes dans le code. Exemple : Testlog4.main(TestLog4.java:10)
%x : affiche le NDC (environnement de diagnostic imbriqué) associé au thread actuel, notamment utilisé dans les applications multi-clients et multi-thread comme les servlets Java.
%% : afficher un caractère "%"
%F : afficher le nom du fichier où le message de journal est généré
%L : afficher le numéro de ligne dans le code
%m : afficher la ligne numéro spécifié dans le message de code, informations de journal spécifiques générées
%n : sortie d'un retour chariot et d'un saut de ligne, la plate-forme Windows est "rn", la plate-forme Unix est "n", sortie de ligne d'informations du journal

%M représente le nom de la méthode

Vous pouvez ajouter des modificateurs entre % et les caractères du motif pour contrôler sa largeur minimale, sa largeur maximale et l'alignement du texte. Par exemple : 1)%20c : Spécifiez le nom de la catégorie de sortie. La largeur minimale est de 20, si le nom de la catégorie est inférieur à 20. 2)%-20c : Spécifiez le nom de la catégorie de sortie. La largeur minimale est de 20. Si le nom de la catégorie est inférieur à 20, le signe "-" spécifie l'alignement à gauche.
3)%.30c : Précisez le nom de la catégorie de sortie. La largeur maximale est de 30. Si le nom de la catégorie est supérieur à 30, les caractères supplémentaires à gauche seront coupés, mais s'il est inférieur à 30. , il n'y aura pas d'espace. 4)%20.30c : Si le nom de la catégorie est inférieur à 20, remplissez les espaces et alignez-le à droite. Si le nom comporte plus de 30 caractères, tronquez les caractères à partir de la gauche.

Pour accéder à Log4J dans le programme, vous devez utiliser le fichier JAR Log4J.
L'utilisation de Log4J dans le programme comprend les processus suivants :

l Obtenir l'enregistreur

l Lire le fichier de configuration et configurer l'environnement Log4J

l Afficher les informations du journal

Avant d'apprendre Log4J, nous devons comprendre les deux interfaces courantes LogFactory et Log dans le package de journaux général. Leur utilisation est présentée ci-dessous.

Interface de journal

Le package de journalisation général divise les messages de journal en 6 niveaux : FATAL (fatal), ERROR (erreur), WARN (avertissement), INFO (information), DEBUG (débogage) ) et TRACE (détails). Parmi eux, FATAL a le niveau le plus élevé et TRACE a le niveau le plus bas. Le package de journaux général utilise un mécanisme de niveau de journalisation pour contrôler de manière flexible le contenu du journal de sortie.

L'interface org.apache.commons.logging.Log représente le logger, qui fournit un ensemble de méthodes pour générer des journaux :

l fatal(Object message) : Sortie des messages de journal de niveau FATAL.

l erreur (message d'objet) : message de journal de niveau ERREUR de sortie.

l ……

l trace (Message d'objet) : Sortie des messages de journal de niveau TRACE.

Pour la méthode de sortie de journaux ci-dessus, cette méthode ne sera réellement exécutée que lorsque le niveau du journal qu'elle génère est supérieur ou égal au niveau de journal configuré pour le journal. Par exemple, si le niveau de journalisation de l'enregistreur est WARN, alors dans le programme, c'est fatal(), error() et warn() seront exécutées, mais les méthodes info(), debug() et trace() le seront non exécuté .

L'interface Log fournit également un ensemble de méthodes pour déterminer si la sortie de niveaux spécifiques de messages de journal est autorisée :

l isFatalEnabled()

l isErrorEnabled()

l ……

l isTraceEnabled()

Avant que le programme ne génère un message de journal d'un certain niveau, il est recommandé d'appeler la méthode ci-dessus pour déterminer si le journal de ce Le niveau peut être affiché, ce qui contribue à améliorer les performances de l'application. Par exemple, le code suivant ajoute d'abord le message de journal au StringBuffer, et appelle enfin la méthode debug() du logger pour afficher le journal :

StringBuffer buf = new StringBuffer();

buf.append(" Connexion réussie - ");

buf.append("Nom:");

buf.append(nom d'utilisateur);

log.debug (buf.toString() ; Toutes les opérations seront redondantes. Afin d'améliorer les performances, vous pouvez utiliser raisonnablement la méthode isDebugEnabled() pour éviter que l'application effectue des opérations redondantes :

if(log.isDebugEnabled){

StringBuffer buf = new StringBuffer();

buf.append(“Connexion réussie - ”);

buf.append(“Nom :”);

buf.append(nom d'utilisateur);

log.debug(bug.toString());

}

(

deux)LogFactoryinterface L'interface org.apache.commons.logging.LogFactory fournit deux méthodes statiques pour obtenir des instances de logger :

public static Log getLog(String nom) lance LogConfigurationException ;

journal statique public getLog(Class class) lève LogConfigurationException ;

La première méthode getLog() utilise le paramètre name comme nom de l'enregistreur ; la deuxième méthode getLog() utilise le nom de la classe spécifiée par le paramètre class comme nom du logger ; logger. Ce qui suit est une implémentation de la deuxième méthode getLog() :

le journal statique public getLog (Class class) est lancé. LogConfigurationException{

getLog(class.getName); //call getLog(String name)

}

Summary

Log4J est principalement composé de 3 composants majeurs : Logger, Appender et Layout. Logger contrôle la sortie des informations du journal ; Appender détermine la destination de sortie des informations du journal ; Layout détermine le format de sortie des informations du journal. Log4J permet aux utilisateurs de configurer ces composants de manière flexible dans les fichiers de configuration. Il est très pratique d'utiliser Log4J dans un programme. Il vous suffit d'abord d'obtenir le logger, puis de lire le fichier de configuration et de configurer l'environnement Log4J. Vous pouvez ensuite appeler la méthode appropriée de la classe Logger pour générer des journaux partout où vous avez besoin de sortir. se connecte au programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!