1: Introduction à Log4J Introduction
Log4j est un projet open source d'Apache. Le format de sortie de chaque journal; Ce qui est le plus intéressant, c'est que ceux-ci peuvent être configurés de manière flexible via un fichier de configuration sans modifier le code de l'application.
En outre, via Log4J d'autres interfaces linguistiques, vous pouvez utiliser Log4j dans les programmes C, C ++, .NET, PL / SQL. Composant. De plus, en utilisant diverses extensions tierces, vous pouvez facilement intégrer LOG4J dans les applications J2EE, Jini et même SNMP.
2. Exemples débutants
1. Créez un nouveau projet Java, importez le package log4j-1.2.17.jar, et le répertoire final de l'ensemble du projet est le suivant
2. Créer et définir Log4j.properties au même niveau
### installation###
log4j.rootlogger = debug, stdout, d, e
### Sortir les informations pour contrôler l'ascenseur ####
log4j.appenden
log4j.appender.stout.target = System.out
log4j.appenden
log4j.appender.stout.layout.conversionPattern = [% -5p]% d {yyyy-mm-dd hh: mm: ss, ssS} Méthode:% l% n% m% n
### Journaux de sortie ci-dessus du niveau de débogage à = e: //logs/error.log ###
log4j.appenden
log4j.appender.d.file = e: //logs/log.log
log4j.appender.d.append = true
log4j.appender.d.threshold = débogue
log4j.appender.d.layout = org.apache.log4j.patternlayout
log4j.appender.d.layout.conversionPattern =% -d {yyyy-mm-dd hh: mm: ss} [% t:% r] - [% p]% m% n
### Journaux de sortie au-dessus du niveau d'erreur à = e: //logs/error.log ###
log4j.appenden
log4j.appender.e.file = e: //logs/error.log
log4j.appender.e.append = true
log4j.appender.e.threshold = erreur
log4j.appender.e.layout = org.apache.log4j.patternlayout
log4j.appender.e.layout.conversionPattern =% -d {yyyy-mm-dd hh: mm: ss} [% t:% r] - [% p]% m% n
3. Définir le contenu du journal
package com.mucfc; import org.apache.log4j.logger; / ** * @ auteur linbingwen * @ 18 mai 2015 9:14:21 * / public class test {private static logger loggg er = logger.getlogger (test. classe); : :::::::::::::::::::::::::::::::::::- : :::::::::::::::::::::::::::::::::::- :::::::::::::::::::::::::: Debug ("This is Debug Message."); Message d'informations. "); // Enregistrer les informations de niveau d'erreur Logger.Error (" Ceci est le message d'erreur. ");}}4. Résultat de sortie
(1) Tout d'abord, les informations de la console
(2) Examinons le fichier de sortie
Le contenu est le suivant et il est constaté qu'il a été publié au document correspondant selon les besoins.
3. Méthode d'utilisation de base de log4j
Log4j se compose de trois composants importants: la priorité des informations du journal, la destination de sortie des informations du journal et le format de sortie des informations du journal. La priorité des informations sur le journal est de haut en bas. Fichier; et la sortie est le format contrôle le contenu d'affichage des informations de journal.
2.1
En fait, vous ne pouvez pas non plus utiliser des fichiers de configuration, mais configurez l'environnement log4j dans votre code. Cependant, l'utilisation des fichiers de configuration rendra votre application plus flexible. Log4j prend en charge deux formats de fichiers de configuration, l'un est un fichier de format XML et l'autre est un fichier de fonctionnalité Java (key = valeur). Ci-dessous, nous introduisons la méthode d'utilisation des fichiers de fonctionnalités Java comme fichiers de configuration:
1. Configurez le journaliste racine, sa syntaxe est:
LOG4J.ROOTLOGGER = [NIVEAU], APPENDERNAME, APPENDERNAME,…
Parmi eux, le niveau est la priorité de l'exploitation forestière, divisée en off, mortelle, erreur, avertissement, info, débogage, tout ou le niveau que vous définissez. LOG4J recommande d'utiliser seulement quatre niveaux, avec la priorité de haute à faible, à savoir l'erreur, la prévient, les informations et le débogage. Selon le niveau défini ici, vous pouvez contrôler les commutateurs au niveau correspondant des informations de journal dans l'application. Par exemple, si le niveau d'information est défini ici, toutes les informations de journal de niveau de débogage dans l'application ne seront pas imprimées. APPENDERNAME fait référence à la sortie des informations du journal B. Vous pouvez spécifier plusieurs destinations de sortie en même temps.
2. Configurez l'appender de destination pour sortir les informations du journal, et sa syntaxe est:
log4j.appender.appendername = entièrement.qualified.name.of.appender.class
log4j.appender.appendername.option1 = value1
…
log4j.appender.appendername.option = valluen
Parmi eux, les annexes fournies par LOG4J sont les suivantes:
org.apache.log4j.consoleAPpender (console),
org.apache.log4j.fileAPpender (fichier),
org.apache.log4j.dailyrollingFileAPender (génère un fichier journal tous les jours),
org.apache.log4j.rollingFileAppender (un nouveau fichier est généré lorsque la taille du fichier atteint la taille spécifiée),
org.apache.log4j.writerAppender (envoyer des informations de journal au format de flux à n'importe quel endroit spécifié)
3. Configurez le format (mise en page) des informations du journal, et sa syntaxe est:
LOG4J.APPENDER.APPENDERNAME.LAYOUT = FOLLOD.QUALIFIED.NAME.OF.LAYOUT.CLASS
log4j.appender.appendername.layout.option1 = value1
…
log4j.appender.appendername.layout.option = valluen
Parmi eux, il y a plusieurs dispositions fournies par LOG4J:
org.apache.log4j.htmllayout (mise en page sous forme de table html),
org.apache.log4j.patternlayout (le mode de mise en page peut être spécifié de manière flexible),
org.apache.log4j.simplelayout (contient le niveau et la chaîne d'informations des informations du journal),
org.apache.log4j.ttcclayout (y compris le temps, le thread, la catégorie, etc. de la génération de journaux)
LOG4J utilise un format d'impression similaire à la fonction printf dans le langage C pour formater les informations du journal, et les paramètres d'impression sont les suivants:% M Le message spécifié dans le code de sortie
% P Priorité de sortie, c'est-à-dire le débogage, les informations, les avertissements, l'erreur, fatal
% r Sortie Le nombre de millisecondes prélevées depuis le début de l'application pour produire les informations du journal
% C produit la catégorie, généralement le nom complet de la classe où elle est située
% T produit le nom de thread qui génère l'événement de journal
% N sort une rupture de ligne de retour du chariot, la plate-forme Windows est "RN", la plate-forme UNIX est "N"
% D produit la date ou l'heure du point de temps du journal. : 18 octobre 2002 22:10:28, 921
% L Sortie de l'emplacement où l'événement de journal se produit, y compris le nom de classe, le thread qui s'est produit et le nombre de lignes dans le code. Exemple: testlog4.main (testlog4.java:10)
2.2.
1. Obtenez l'enregistreur
En utilisant Log4J, la première étape consiste à obtenir l'enregistreur de journal, qui sera responsable du contrôle des informations du journal. La syntaxe est:
Public Static Logger GetLogger (nom de chaîne)
Obtenez le bûcheron par le nom spécifié et, si nécessaire, créez un nouvel enregistreur pour le nom. Le nom est généralement nommé dans cette classe, comme:
STATIC LOGGER LOGGER = Logger.GetLogger (ServerWithLog4J.Class.getName ())
2. Lisez le fichier de configuration
Après avoir obtenu le journaliste, la deuxième étape configurera l'environnement log4j, avec la syntaxe comme:
BasicConfigurator.Configure (): utilisez automatiquement et rapidement l'environnement log4j par défaut.
PropertyConfigurator.Configure (String ConfigFileName): Lisez les fichiers de configuration écrits à l'aide des fichiers de fonctionnalités de Java.
DomConfigurator.Configure (String FileName): Lisez les fichiers de configuration dans le formulaire XML.
3. Insérer des informations d'enregistrement (informations sur le journal du format)
Lorsque les deux étapes nécessaires sont terminées, vous pouvez facilement insérer les instructions de journalisation des différents niveaux de priorité partout où vous souhaitez enregistrer.
Logger.debug (message objet);
Logger.info (message objet);
Logger.warn (message objet);
Logger.Error (message d'objet);
2.3.
Chaque enregistreur est soumis à un niveau de journal (niveau de journal) pour contrôler la sortie des informations du journal. Les niveaux de journal sont divisés en:
R: Le plus haut niveau est utilisé pour fermer toute la journalisation.
B: Fatal indique que chaque événement d'erreur critique entraînera la sortie de l'application.
C: L'erreur indique que bien qu'un événement d'erreur se produise, il n'affecte toujours pas le fonctionnement continu du système.
D: chaud indique qu'il y aura des situations d'erreur potentielles.
E: Informations Généralement et au niveau grossier, il met l'accent sur l'ensemble du fonctionnement de l'application.
F: Le débogage est généralement utilisé au niveau fin et est très utile pour les applications de débogage.
G: Tout le niveau minimum, utilisé pour ouvrir toute la journalisation.
Les niveaux ci-dessus sont définis dans la classe de niveau org.apache.log4j. LOG4J recommande uniquement d'utiliser 4 niveaux, avec la priorité de haut à faible, l'erreur, la prévient, les informations et le débogage. En utilisant le niveau de journal, vous pouvez contrôler la sortie des informations de journal au niveau correspondant dans l'application. Par exemple, si B est utilisé, toutes les informations de journal sous le niveau d'information (telles que le débogage) dans l'application ne seront pas imprimées.
4. Utilisez des instances log4j dans les projets Web
Le code ci-dessus décrit l'application simple de log4j, et en fait, l'utilisation de log4j est si simple et pratique. Bien sûr, en plus de la méthode de configuration ci-dessus, il y a d'autres choses, telles que la création d'une application J2EE. dans web.xml.
1. L'utilisation log4j des applications Web utilise essentiellement: Créer un nouveau servlet, qui exécute la configuration de Log4j dans la fonction INIT. Généralement, il s'agit de lire le fichier de configuration. Par conséquent, vous devez configurer ce servlet dans web.xml et définir le chargement sur le startup sur 1.
2. Ce servlet Configuration Log4j est de lire le fichier de configuration, puis d'appeler la fonction de configuration. Il y a deux questions ici: 1. Vous devez savoir où se trouve le fichier; 2. Vous avez besoin du type de fichier correct
3. L'emplacement du fichier de configuration peut être configuré dans web.xml.
4. Il existe généralement deux types de types de fichiers, l'un est le fichier de propriété Java, et l'autre est un fichier XML
Le contenu général du fichier de configuration: log4j peut spécifier le niveau minimum du niveau de journal de sortie, ainsi que le format de configuration de sortie du journal. Chaque journal peut spécifier plusieurs méthodes de sortie.
(1) Créer un projet Web, le répertoire final de l'ensemble du projet est le suivant
(2) La configuration Web.xml est la suivante:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http: // java .sun.com / xml / ns / javaee "xsi: schemalocation =" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0 .xsd "id =" webApp_id "version =" 3.0 "> <splay-name> logariking </splay-name> <vrlet> <servlet-name> log4jtestServlet </ servlet-name> <servlet-cl ass> com.mucfc Log4JTestServlet </ Servlet-Class> </vrleth </ servlet-class> <Init-Param> <Am param-name> log4j-properties-location </ param-name> <param-value> /web-inf/classes/log4j.properties </ param-value> </ init -Param> <onde-on-startup> 1 </ charge-on-startup> </ servlet> <servlet-mapping> <servlet-name> log4jtestServlet </vrlett-name> <url-potern> / test </ URL -Pattern> </ servlet-mapping> </ web-app>
(3) Fichier de configuration log4j.properties
### Définir les niveaux du journal ###
log4j.rootlogger = debug, stdout, d, e
log4j.appenden
log4j.appender.stout.target = System.out
log4j.appenden
log4j.appender.stout.layout.conversionPattern = [% -5p]% d {yyyy-mm-dd hh: mm: ss, ssS} Méthode:% l% n% m% n
log4j.appenden
log4j.appender.d.file = f: //logs/log.log
log4j.appender.d.append = true
log4j.appender.d.threshold = débogue
log4j.appender.d.layout = org.apache.log4j.patternlayout
log4j.appender.d.layout.conversionPattern =% -d {yyyy-mm-dd hh: mm: ss} [% t:% r] - [% p]% m% n
log4j.appenden
log4j.appender.e.file = f: //logs/error.log
log4j.appender.e.append = true
log4j.appender.e.threshold = erreur
log4j.appender.e.layout = org.apache.log4j.patternlayout
log4j.appender.e.layout.conversionPattern =% -d {yyyy-mm-dd hh: mm: ss} [% t:% r] - [% p]% m% n
(4) Le servlet a initialisé dès que le conteneur Web arrive
Log4Jinitservlet.javapackage com.MUCFC; ; * Classe d'implémentation de servlet Log4JiniTServlet * / @webservlet ("/ log4JiniTServlet") Classe publique Log4JiniServlet étend httpServlet {private static final s erraalversionuid = 1l; )); "); String log4jLocation = config.getInitParAmètre (" log4j-properties-location "); servletContext sc = config.getServletContex Fichier d'initialisation des propriétés-localisation, utilisez donc BasicConfigurator pour initialiser "); BasicConfigurator.Configure ();} else {String webAppPath = sc.getRealPath (" / "); String log4jprop = webAppPath + l og4jLocation; file yomamayesthessaysyomama = new File (log4jprop ); ** "+ log4jprop +" Le fichier n'a pas été trouvé, donc initialisé avec BasicConfigurator "); BasicConfigurator.Configure ();}} super.init (config);} / ** * @see httpservlet # DOGT HttpServletResponse Response) * / Protected void doGet (HttpServletRequest Request, HttpServletResponse Response) lève ServletException, ioException {// TODO Auto-généré par Stub} / ** * @see httpservle T # dopost (httpserrequest request, httServletRerserSponserson DOPOST (HttpServLetRequest Request, HttpServletResponse Response) Throw S ServletException, ioException {// TODO Méthode générée automatiquement Stub}}Call Log Log4JtestServlet, Java
package com.mucfc; http .httpservletRequest; SerialVersionUID = 1l; Logger statique privé = Logger.getLogger (log4jtestServlet.class); * * * @see servlet # init (ServletConfig) * / public void init (servletconfig config) lève ServletException {// TODO Méthode générée automatiquement Protected void doGet (requête HttpServletRequest, réponse httpservletResponse) lève ServletException, ioException {// Enregistrer le niveau de débogage logger.debug ("Ceci est debug m essage."); Message. "); // Enregistrer les informations de niveau d'erreur Logger.Error (" Ceci est un message d'erreur. ");} / ** * @see httpservlet # doPost (httpservletRequest request, httpservletResponse réponse) * / protected void doPost (httpservletrequest request, HttpServletResponse Réponse) lève Servlexception, ioException {doGet (demande, réponse);Ensuite, nous sommes en cours d'exécution, voyons les résultats:
Résultat de sortie:
5. Utilisez Log4J au printemps
Ici, nous devons implémenter l'utilisation des projets Spring dans les projets Web pour utiliser LOG4J
(1) Connectez-vous au projet ci-dessus, puis importez le package à ressort
(2) web.xml ajouté
<! - Définir le répertoire racine -> <context-param> <param-name> webApprootKey </ param-name> <param-value> webApp.root </ param-valeur> param> <param-name> log4jconfiglocation </ param-name> <param-évalue> /web-inf/classes/log4j.properties </ param-value> </ context-param> <! - 3000 signifie un watchdog d'ouverture Le thread analyse le fichier de configuration change toutes les 60 secondes; > </ Context-Param> <Douger> <auditeur-classe> org.springframework.web.util.log4jconfigListener </ auteur-class> </diner>
L'ensemble du contenu est le suivant:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http: // java .sun.com / xml / ns / javaee "xsi: schemalocation =" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0 .xsd "id =" webApp_id "version =" 3.0 "> <splay-name> logariking </splay-name> <vrlet> <servlet-name> log4jtestServlet </ servlet-name> <servlet-cl ass> com.mucfc . MUCFC.LOG4JINITSERVLET </ Servlet-Class> <Init-Param> <AmAm-Name> Log4j-properties-location </ Param-Name> <Amam-Value> /web-inf/classes/Log4j.p Roperties </ Param-- Valeur> </ init-Param> <onde-sur-startup> 1 </ charge-on-startup> </ servlet> -> <servlet-mapping> <servlet-name> log4jtestServlet </vrlet-name> <url - Pattern> / test </ url-stern> </ servlet-mapping> <! - Spring Container Chargement -> <disener> <écouteur-class> org.springframework.web.context.contextLoaderListener </ list ener-Class-Class > </ouener> <context-param> <param-name> contextConfigLocation </ param-name> <param-value> classpath: applicationContext.xml </ param-valeur> </ / context-parm am> <! - set Root Directory- -> <context-param> <param-name> webApprootKey </ Param-name> Nom> log4jconfiglocation </ param-name> <param-value> /web-inf/classes/log4j.properties </ param-value> </ context-param> <! - 3000 signifie ouvrir un thread de surveillance pour scanner la configuration Fichier toutes les 60 secondes modifies; Param> <disener> <écouteur-classe> org.springframework.web.util.log4jconfigListener </ auteur-classe> </diner> </low-applicner>
Ici log4jinitservlet.java équivaut à être inutile.
(2) ApplicationContext.xml
Pas de contenu:
<? xml version = "1.0" Encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org / 2001 / XMLSCHEMA-INSTANCE "XMLNS: context =" http://www.springframework.org/schema/context "xmlns: aop =" http://www.springframework.org/sche ma / aop "xsi: schemalocation = "http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/springframeworks-3.2.xsdhttp://www.springframework.org / schema / aophttp: //www . "> </ beans>
(3) De cette façon, le journal sera démarré avec la fenêtre à ressort
Une fois le programme exécuté, le journal sera imprimé automatiquement
log.log
error.log est vide car il n'imprime que des informations au-dessus du niveau d'erreur
Entrez http: // localhost: 8080 / loglearning2 / Test par le navigateur
Puis ouvrez le fichier
Le tutoriel détaillé sur Java Log4j est ici.