1: Einführung in log4j Einführung
LOG4J ist ein Open -Source -Projekt von Apache. Das Ausgabeformat jedes Protokolls; Am interessantesten ist, dass diese flexibel über eine Konfigurationsdatei konfiguriert werden können, ohne den Code der Anwendung zu ändern.
Darüber hinaus können Sie über log4j andere Sprachschnittstellen log4j in C, C ++, .NET, PL/SQL -Programmen verwenden. Komponente. Darüber hinaus können Sie durch die Verwendung verschiedener Erweiterungen von Drittanbietern Log4J problemlos in J2EE-, Jini- und sogar SNMP-Anwendungen integrieren.
2. Anfänger Beispiele
1. Erstellen Sie ein neues Java-Projekt, importieren
2. Erstellen und setzen Sie log4j.properties auf derselben Ebene
### aufstellen###
log4j.rootlogger = debug, stdout, d, e
### Ausgabeinformationen zum Steuerelement ####
log4j.appender.stdout = org.apache.log4j.conoleAppender
log4j.appender.stdout.target = system.out
log4j.appender.stdout.layout = org.apache.log4j.patternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p]%d {yyyy-mm-dd HH: MM: SS, SSS} Methode:%l%n%m%n
### Ausgabeprotokolle über Debug -Ebene zu = e: //logs/error.log ###
log4j.appender.d = org.apache.log4j.dailyrollingFileAppender
log4j.appender.d.file = e: //logs/log.log
log4j.appender.d.append = true
log4j.appender.d.Threshold = debug
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
### Ausgabeprotokolle über der Fehlerebene zu = e: //logs/error.log ###
log4j.appender.e = org.apache.log4j.dailyrollingFileAppender
log4j.appender.e.file = e: //logs/error.log
log4j.appender.e.append = true
log4j.appender.e.Threshold = Fehler
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. Setzen Sie den Protokollinhalt
Paket com.mucfc; import org.apache.log4j.logger;/** *@Author Linbingwen *@18. Mai 2015 9:14:21 */public class Test {private statische Logger logg er = logger.getLogger (test. Klasse); ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::::::: Debugg ("Dies ist Debug-Nachricht"); .Error ("Dies ist Fehlermeldung.");4. Ausgangsergebnis
(1) Zunächst die Informationen der Konsole
(2) Schauen wir uns die Ausgabedatei an
Der Inhalt ist wie folgt und es wird festgestellt, dass er nach Bedarf an das entsprechende Dokument ausgegeben wurde.
3.. Grundnutzungsmethode von log4j
Log4j besteht aus drei wichtigen Komponenten: der Priorität von Protokollinformationen, dem Ausgabeziel der Protokollinformationen und dem Ausgabeformat der Protokollinformationen. Die Priorität von Protokollinformationen ist von hoch bis niedrig. Datei;
2.1
Tatsächlich können Sie überhaupt keine Konfigurationsdateien verwenden, sondern die Log4J -Umgebung in Ihrem Code konfigurieren. Durch die Verwendung von Konfigurationsdateien wird Ihre Anwendung jedoch flexibler. Log4j unterstützt zwei Konfigurationsdateiformate, eine ist eine XML -Formatdatei und die andere ist eine Java -Funktionsdatei (Key = value). Im Folgenden stellen wir die Methode der Verwendung von Java -Feature -Dateien als Konfigurationsdateien vor:
1. Konfigurieren Sie den Root Logger, seine Syntax lautet:
log4j.rootlogger = [Level], appendername, appendername,…
Unter ihnen ist Level die Priorität der Protokollierung, unterteilt in Off, Fatal, Irrtum, Warn, Info, Debugug, All oder das von Ihnen definierte Niveau. Log4J empfiehlt nur vier Ebenen, wobei Priorität von hoch bis niedrig ist, nämlich Fehler, Warnen, Info und Debuggen. Auf der hier definierten Ebene können Sie die Switches auf die entsprechende Ebene der Protokollinformationen in der Anwendung steuern. Wenn hier beispielsweise die Info -Ebene definiert ist, werden alle Informationen zur Debug -Ebene in der Anwendung nicht ausgedruckt. Appendername bezieht sich darauf, wo die B -Protokollinformationen ausgegeben werden. Sie können gleichzeitig mehrere Ausgabeziele angeben.
2. Konfigurieren Sie den Ziel Appender, um die Protokollinformationen auszugeben, und seine Syntax lautet:
log4j.appender.appendername = vollständig.qualified.name.of.appender.class
log4j.appender.appendername.option1 = value1
…
log4j.appender.appendername.option = valuen
Unter ihnen sind die von Log4J bereitgestellten Appender wie folgt:
org.apache.log4j.conoleAppender (Konsole),
org.apache.log4j.fileAppender (Datei),
org.apache.log4j.dailyrollingFileAppender (generiert jeden Tag eine Protokolldatei),
org.apache.log4j.rollingFileAppender (eine neue Datei wird generiert, wenn die Dateigröße die angegebene Größe erreicht).
org.apache.log4j.writerAppender (Senden Sie Protokollinformationen im Stream -Format an einen bestimmten Ort)
3. Konfigurieren Sie das Format (Layout) von Protokollinformationen, und seine Syntax lautet:
log4j.appender.appendername.layout = vollständig.qualified.name.of.layout.class
log4j.appender.appendername.layout.option1 = value1
…
log4j.appender.appendername.layout.option = valuen
Unter ihnen gibt es mehrere Layouts von Log4J:
org.apache.log4j.htmllayout (Layout in HTML -Tabellenformular),
org.apache.log4j.patternLayout (der Layoutmodus kann flexibel angegeben werden),
org.apache.log4j.simplelayout (enthält die Ebene und Informationszeichenfolge von Protokollinformationen),
org.apache.log4j.ttcclayout (einschließlich Zeit, Thread, Kategorie usw. der Protokollgenerierung)
Log4J verwendet ein Druckformat, das der Printf -Funktion in C -Sprache ähnelt, um die Protokollinformationen zu formatieren, und die Druckparameter sind wie folgt: %m Die im Ausgabecode angegebene Nachricht
%p Ausgangspriorität, d. H. Debug, Info, Warn, Fehler, tödlich
%r Ausgabe Die Anzahl der Millisekunden, die vom Beginn der Anwendung aufgenommen wurden, um die Protokollinformationen auszugeben
%c gibt die Kategorie aus, normalerweise den vollständigen Namen der Klasse, sie befindet sich
%t gibt den Threadnamen aus, der das Protokollereignis generiert
%n gibt einen Wagenrücklauf -Break aus, Windows -Plattform ist "RN", Unix -Plattform ist "n"
%D gibt das Datum oder die Uhrzeit des Protokollzeitpunkts aus. : 18. Oktober 2002 22:10:28, 921
%l Ausgabe des Ortes, an dem das Protokollereignis auftritt, einschließlich des Klassennamens, des auftretenden Threads und der Anzahl der Zeilen im Code. Beispiel: testlog4.main (testlog4.java:10)
2.2. Verwenden Sie log4j im Code
1. Holen Sie sich den Rekorder
Mit Log4J besteht der erste Schritt darin, den Protokollrekorder zu erhalten, der für die Steuerung der Protokollinformationen verantwortlich ist. Die Syntax ist:
öffentlicher statischer Logger getLogger (String -Name)
Holen Sie sich den Logger nach dem angegebenen Namen und erstellen Sie bei Bedarf einen neuen Protokoll für den Namen. Der Name wird in dieser Klasse allgemein benannt, wie beispielsweise:
statischer Logger logger = logger.getLogger (serverwithlog4j.class.getname ())
2. Lesen Sie die Konfigurationsdatei
Nach dem Erhalt des Loggers konfiguriert der zweite Schritt die Log4J -Umgebung mit der Syntax als:
BasicConfigurator.Configure (): Automatisch und schnell die Standard -Log4J -Umgebung verwenden.
PropertyConfigurator.configure (String configFileName): Konfigurationsdateien mit den Feature -Dateien von Java lesen.
DomConfigurator.Configure (String -Dateiname): Konfigurationsdateien in XML -Formular lesen.
Fügen Sie Datensatzinformationen ein (Formatprotokollinformationen)
Wenn die beiden vorherigen erforderlichen Schritte ausgeführt werden, können Sie die Protokollierungsanweisungen mit unterschiedlichen Prioritätsniveaus überall einfügen, an dem Sie protokollieren möchten.
Logger.debug (Objektnachricht);
Logger.info (Objektnachricht);
Logger.warn (Objektnachricht);
Logger.Error (Objektnachricht);
2.3
Jeder Logger wird einer Protokollebene (Protokollebene) ausgesetzt, um die Ausgabe von Protokollinformationen zu steuern. Die Protokollebenen sind unterteilt in:
A: Außerhalb des höchsten Levels wird alle Protokollierung geschlossen.
B: Fatal zeigt an, dass jedes kritische Fehlerereignis dazu führt, dass die Anwendung beendet.
C: Der Fehler zeigt an, dass ein Fehlerereignis zwar auftritt, er jedoch den fortgesetzten Betrieb des Systems dennoch nicht beeinflusst.
D: Warm zeigt an, dass es potenzielle Fehlersituationen gibt.
E: Info im Allgemeinen und auf grobkörniger Ebene betont es den gesamten Betrieb der Anwendung.
F: Debugg wird im Allgemeinen auf feinkörniger Ebene verwendet und ist sehr hilfreich für Debugging-Anwendungen.
G: Alle Mindestpegel, die zum Öffnen der gesamten Protokollierung verwendet wird.
Die obigen Ebenen sind in der org.apache.log4j.level -Klasse definiert. Log4J empfiehlt nur, 4 Stufen zu verwenden, wobei Priorität von hoch bis niedrig, Fehler, Warn, Info und Debugug vorrangig ist. Durch die Verwendung der Protokollebene können Sie die Ausgabe von Protokollinformationen auf der entsprechenden Ebene in der Anwendung steuern. Wenn B beispielsweise verwendet wird, werden alle Protokollinformationen unterhalb der Info -Ebene (z. B. Debugg) in der Anwendung nicht ausgedruckt.
4. Verwenden Sie log4j -Instanzen in Webprojekten
Der obige Code beschreibt die einfache Anwendung von LOG4J und tatsächlich ist es so einfach und bequem, dass Log4J verwendet wird. Zusätzlich zu der oben genannten Konfigurationsmethode gibt es andere Dinge, z. B. eine J2EE -Anwendung. in web.xml.
1. Die Verwendung von Webanwendungen log4j verwendet im Grunde genommen ein neues Servlet, das die Konfiguration für log4j in der Init -Funktion ausführt. Im Allgemeinen wird die Konfigurationsdatei gelesen. Daher müssen Sie dieses Servlet in web.xml konfigurieren und Lade-On-Startup auf 1 festlegen.
2. Mit diesem Servlet -Konfigurations -Log4J werden die Konfigurationsdatei lesen und dann die Konfigurationsfunktion aufrufen. Hier gibt es zwei Fragen: 1. Sie müssen wissen, wo sich die Datei befindet. 2. Sie benötigen den richtigen Dateityp
3. Die Konfigurationsdateisposition kann in web.xml konfiguriert werden.
4.. Es gibt im Allgemeinen zwei Arten von Dateitypen, eine ist Java -Eigenschaftsdatei und die andere ist die XML -Datei
Der allgemeine Inhalt der Konfigurationsdatei: LOG4J kann die minimale Ebene der Ausgabeprotokollebene sowie das Ausgangskonfigurationsformat des Protokolls angeben. Jedes Protokoll kann mehrere Ausgabemethoden angeben.
(1) Erstellen Sie ein Webprojekt, das endgültige Verzeichnis des gesamten Projekts ist wie folgt
(2) Die Konfiguration von web.xml lautet wie folgt:
<? .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 "> <Anzeige-Name> loglearning </display-name> <servlet> <servlet-name> log4jTestServlet </servlet-name> <servlet-cl ass> com.mucfc LOG4JTESTServlet </Servlet-Klasse> </Servlet> <!-Servlet zum Starten von LOG4JConFigLocation-> <servlet> <servlet-name> log4jinitServlet </servlet-name> <servlet-cla SS> com.mucfc.log4jinits-name </servlet-classe> <init-param> <param-name> log4j-properties-location </param-name> <param-value> /web-inf/classes/log4j.properties </param-value> </ INIT -PARAM> <LOAD-ON-STARTUP> 1 </load-on-Startup> </Servlet> <Servlet-Mapping> <Servlet-Name> log4jTestServlet </Servlet-Name> <URL-Pattern>/test </ URL -Pattern> </Servlet-Mapping> </web-App>
(3) Konfigurationsdatei log4j.properties
### Setzen Sie Protokollebenen ###
log4j.rootlogger = debug, stdout, d, e
log4j.appender.stdout = org.apache.log4j.conoleAppender
log4j.appender.stdout.target = system.out
log4j.appender.stdout.layout = org.apache.log4j.patternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p]%d {yyyy-mm-dd HH: MM: SS, SSS} Methode:%l%n%m%n
log4j.appender.d = org.apache.log4j.dailyrollingFileAppender
log4j.appender.d.file = f: //logs/log.log
log4j.appender.d.append = true
log4j.appender.d.Threshold = debug
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.appender.e = org.apache.log4j.dailyrollingFileAppender
log4j.appender.e.file = f: //logs/error.log
log4j.appender.e.append = true
log4j.appender.e.Threshold = Fehler
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) Das Servlet wurde initialisiert, sobald der Webcontainer kommt
Log4jinitServlet.javapackage com.mucfc; ; * Servlet -Implementierungsklasse log4jinitServlet */ @WebServlet ("/ log4jinitServlet") öffentliche Klasse log4jinitServlet erweitert httpServlet {private statische endgültige S -Eraalversionuid = 1L; ); "); String log4jLocation = config.GetInitParameter (" log4j-properties location "); servletContext sc = config.getServletContext (); if (log4jLocation == nul l) {System.err.println (" *** no log4j- Initialisierungsdatei der Eigenschaften-Lokalisierung, verwenden Sie also BasicConfigurator, um zu initialisieren "); BasicConfigurator.configure ();} else {string webapppath = sc.getrealpath ("/"); String log4jprop = webapppath + l og4jlocation; Datei yomamayästhissayyomama = neue Datei (Log4JPrope ); ** " + log4JProp +" Die Datei wurde nicht gefunden, so mit BasicConfigurator initialisiert "); BasicConfigurator.configure ();}} Super.init (config);} /*** @see httpServlet#dagget (httpServletRequest Request EST, EST, EST, EST, EST, EST. HttpServletResponse-Antwort) */ Protected void dodget (httpServletRequest-Anforderung, HttpServletResponse-Antwort) löst ServletException, IOException {// toDo auto-generierter Methode Stub}/ ** *@seee HttpServle T#Dopost (HTtpLected Request, HttpServe T#Dopost) * */ httpSquest Request, httpServe t#Dopost) aus. Dopost (HttpServletRequest-Anforderung, httpServletResponse-Antwort) servletException, ioException {// Todo automatisch generierte Methode Stub}}Rufen Sie log log4jTestServlet, Java auf
Paket com.mucfc; http .httpServletRequest; Serialversionuid = 1L; * * * @see servlet#init (servletConfig) */ public void init (servletConfig config) löst servletException {// todo auto-generierter Methode Stub}/ ** * @ siehe httpServlet#dagget (httpServletRequestanfrage, httpServletResponde-Antwort) *//// httpServletRequest-Anforderung) aus. Protected Void DoGet (httpServletRequest-Anforderung, httpServletResponse-Antwort) löst ServletException aus, IOException {// Debug-Level-Informations-Logger.debug ("Dies ist Debug-MSSAGE"); Nachricht. "); // Fehlerstufe Information Logger.Error (" Dies ist Fehlermeldung. ");} / ** * @see httpServlet#Dopost (httpServletRequest -Anforderung, HttpServletResponde -Antwort) * / Protected void Dopost (httpServletrequest -Anforderung, Anfrage, Protected void Dopost (httpServletrequest -Anforderung, Anforderung, Protected Void Dopost (httpServletRequest Request), Anforderung, Protected Void (httpServletrequest Request) HttpServletResponse -Antwort) löscht ServletException, IOException {dagget (Request, Antwort);Als nächstes läuft wir die Ergebnisse:
Ausgangsergebnis:
5. Verwenden Sie log4j im Frühjahr
Hier müssen wir die Verwendung von Frühling in Webprojekten zur Verwendung von LOG4J implementieren
(1) Stellen Sie eine Verbindung zum obigen Projekt her und importieren Sie dann das Spring -Paket
(2) web.xml hinzugefügt
<!-Root Directory-> <context-param> <param-name> webappootkey </param-name> <param-value> webapp.root </param-value> </context-param> <context- Param> <param-name> log4jconfigLocation </param-name> <param-value> /web-inf/classes/log4j.properties </param-Value> </context-param> <!-3000 bedeutet einen Öffnungsantriebsantrieb. Der Thread scannt die Konfigurationsdatei alle 60 Sekunden; > </context-param> <hörer> <hörerklasse> org.springframework.web.util.log4jconfiglistener </listener-Klasse> </listener>
Der gesamte Inhalt ist wie folgt:
<? .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 "> <Anzeige-Name> loglearning </display-name> <servlet> <servlet-name> log4jTestServlet </servlet-name> <servlet-cl ass> com.mucfc . mucfc.log4jinitServlet </servlet-class> <init-param> <param-name> log4j-properties-location </param-name> <param-value> /web-inf/classes/log4j.p ROPERTIES </param- value> </init-param> <load-on-startup> 1 </load-on-startup> </servlet>-> <Servlet-Mapping> <servlet-name> log4jTestServlet </servlet-name> <url -Muster>/test </url-pattern> </servlet-mapping> <!-Springbehälter Loading-> <Hörer> <Hörer-Klasse> org.springframework.web.Context.ContextloaderListener </Lister-Energklasse > </listener> <context-param> <param-name> contextconfigLocation </param-name> <param-value> classPath: applicationContext.xml </param-value> </context-par am> <!-Set- Root Directory--> <context-Param> <param-name> webappootkey </param-name> <param-value> webapp.root </param-value> </context-param> <context-param> <param- Name> log4jconfigLocation </param-name> <param-value> /web-inf/classes/log4j.properties </param-Value> </conxt-param> <!-3000 bedeutet, einen Watchdog-Thread zu öffnen, um die Konfiguration zu scannen, um die Konfiguration zu scannen, um die Konfiguration zu scannen Datei alle 60 Sekunden ändert sich; Param> <Hörer> <Hörer-Klasse> org.springframework.web.util.log4jconfigListener </Listener-Klasse> </listener> </web-app>
Hier log4jinitServlet.java entspricht nutzlos.
(2) applicationContext.xml
Kein Inhalt:
<? /2001/xmlschemasinstance "xmlns: context =" http://www.springframework.org/schema/context "xmlns: aop =" http://www.spingframework.org/sche ma/aoP "xsi: scheemalocation "http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-geans-3.2.xsdhttp://www.springframework.org/Schema/AOSHTTP: ///www . springframework.org/schema/aop/spring-aop-3.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/cont ext/spring-context-3.2.xsd "> </beans>
(3) Auf diese Weise wird das Protokoll mit dem Federfenster gestartet
Sobald das Programm ausgeführt wird, wird das Protokoll automatisch gedruckt
log.log
Fehler.log ist leer, da nur Informationen über der Fehlerebene gedruckt werden
Geben Sie http: // localhost: 8080/loglearning2/test durch den Browser ein
Öffnen Sie dann die Datei
Das detaillierte Tutorial zu Java Log4J ist hier.