log4j - Szybki przewodnik

log4j to niezawodna, szybka i elastyczna platforma logowania (API) napisana w języku Java, która jest rozpowszechniana na licencji oprogramowania Apache.

log4j został przeniesiony na języki C, C ++, C #, Perl, Python, Ruby i Eiffel.

log4j można w dużym stopniu konfigurować za pomocą zewnętrznych plików konfiguracyjnych w czasie wykonywania. Przegląda proces rejestrowania pod kątem poziomów priorytetów i oferuje mechanizmy bezpośredniego logowania do wielu różnych miejsc docelowych, takich jak baza danych, plik, konsola, UNIX Syslog itp.

log4j ma trzy główne komponenty:

• loggers: Odpowiedzialny za przechwytywanie informacji logowania.

• appenders: Odpowiedzialny za publikowanie informacji logowania do różnych preferowanych miejsc docelowych.

• layouts: Odpowiedzialny za formatowanie informacji logowania w różnych stylach.

Historia pliku log4j

• Rozpoczęty na początku 1996 r. Jako API śledzenia dla projektu EU SEMPRE (Bezpieczny rynek elektroniczny dla Europy).

• Po niezliczonych ulepszeniach i kilku wcieleniach, początkowe API przekształciło się w log4j, popularny pakiet rejestrowania dla Javy.

• Pakiet jest rozpowszechniany na licencji Apache Software License, pełnoprawnej licencji open source certyfikowanej przez inicjatywę open source.

• Najnowszą wersję log4j, w tym pełny kod źródłowy, pliki klas i dokumentację, można znaleźć pod adresem http://logging.apache.org/log4j/.

Log4j Funkcje

• Jest bezpieczny dla wątków.

• Jest zoptymalizowany pod kątem szybkości.

• Opiera się na nazwanej hierarchii rejestratorów.

• Obsługuje wiele programów dołączających dane wyjściowe na rejestrator.

• Wspiera internacjonalizację.

• Nie ogranicza się do wcześniej określonego zestawu udogodnień.

• Zachowanie rejestrowania można ustawić w czasie wykonywania za pomocą pliku konfiguracyjnego.

• Jest przeznaczony do obsługi wyjątków Java od samego początku.

• Używa wielu poziomów, a mianowicie ALL, TRACE, DEBUG, INFO, WARN, ERROR i FATAL.

• Format danych wyjściowych dziennika można łatwo zmienić, rozszerzając klasę Layout .

• Cel danych wyjściowych dziennika, a także strategię pisania można zmienić za pomocą implementacji interfejsu Appender.

• To jest błąd. Jednak, chociaż z pewnością stara się zapewnić dostarczenie, log4j nie gwarantuje, że każda instrukcja dziennika zostanie dostarczona do miejsca docelowego.

Plusy i minusy logowania

Rejestrowanie jest ważnym elementem tworzenia oprogramowania. Dobrze napisany kod rejestrowania zapewnia szybkie debugowanie, łatwą konserwację i uporządkowane przechowywanie informacji o środowisku wykonawczym aplikacji.

Logowanie ma również swoje wady. Może spowolnić aplikację. Jeśli jest zbyt rozwlekły, może powodować ślepotę na przewijanie. Aby złagodzić te obawy, log4j został zaprojektowany tak, aby był niezawodny, szybki i rozszerzalny.

Ponieważ rejestrowanie rzadko jest głównym celem aplikacji, interfejs API log4j stara się być łatwy do zrozumienia i użycia.

Pakiet API log4j jest rozpowszechniany na licencji Apache Software License, pełnoprawnej licencji open source certyfikowanej przez inicjatywę open source.

Najnowszą wersję log4j, w tym pełny kod źródłowy, pliki klas i dokumentację, można znaleźć pod adresem http://logging.apache.org/log4j/.

Aby zainstalować log4j w swoim systemie, pobierz plik apache-log4j-xxxtar.gz z określonego adresu URL i postępuj zgodnie z instrukcjami podanymi poniżej.

Krok 1

Rozpakuj i rozpakuj pobrany plik w katalogu / usr / local / w następujący sposób:

$ gunzip apache-log4j-1.2.15.tar.gz
$ tar -xvf apache-log4j-1.2.15.tar
apache-log4j-1.2.15/tests/input/
apache-log4j-1.2.15/tests/input/xml/
apache-log4j-1.2.15/tests/src/
apache-log4j-1.2.15/tests/src/java/
apache-log4j-1.2.15/tests/src/java/org/
.......................................

Podczas usuwania tarczy utworzyłby hierarchię katalogów o nazwie apache-log4j-xxx w następujący sposób:

-rw-r--r--  1 root root   3565 2007-08-25 00:09 BUILD-INFO.txt
-rw-r--r--  1 root root   2607 2007-08-25 00:09 build.properties.sample
-rw-r--r--  1 root root  32619 2007-08-25 00:09 build.xml
drwxr-xr-x 14 root root   4096 2010-02-04 14:09 contribs
drwxr-xr-x  5 root root   4096 2010-02-04 14:09 examples
-rw-r--r--  1 root root   2752 2007-08-25 00:09 INSTALL
-rw-r--r--  1 root root   4787 2007-08-25 00:09 KEYS
-rw-r--r--  1 root root  11366 2007-08-25 00:09 LICENSE
-rw-r--r--  1 root root 391834 2007-08-25 00:29 log4j-1.2.15.jar
-rw-r--r--  1 root root    160 2007-08-25 00:09 NOTICE
-rwxr-xr-x  1 root root  10240 2007-08-25 00:27 NTEventLogAppender.dll
-rw-r--r--  1 root root  17780 2007-08-25 00:09 pom.xml
drwxr-xr-x  7 root root   4096 2007-08-25 00:13 site
drwxr-xr-x  8 root root   4096 2010-02-04 14:08 src
drwxr-xr-x  6 root root   4096 2010-02-04 14:09 tests

Krok 2

Ten krok jest opcjonalny i zależy od tego, jakich funkcji będziesz używać we frameworku log4j. Jeśli masz już zainstalowane następujące pakiety na swoim komputerze, to jest w porządku, w przeciwnym razie musisz je zainstalować, aby log4j działał.

• JavaMail API:Funkcja logowania oparta na wiadomościach e-mail w log4j wymaga zainstalowania na komputerze interfejsu API Java Mail (mail.jar) z witryny glassfish.dev .

• JavaBeans Activation Framework: Interfejs API Java Mail będzie również wymagał zainstalowania środowiska aktywacji JavaBeans (Activation.jar) na komputerze ze strony http://java.sun.com/products/javabeans/jaf/index.jsp.

• Java Message Service: Kompatybilne z JMS funkcje log4j będą wymagały zainstalowania na komputerze zarówno JMS, jak i Java Naming oraz Directory Interface JNDI z http://java.sun.com/products/jms.

• XML Parser:Do korzystania z log4j potrzebny jest parser XML zgodny z JAXP. Upewnij się, że masz zainstalowany Xerces.jar na swoim komputerze zhttp://xerces.apache.org/xerces-j/install.html.

Krok 3

Teraz musisz skonfigurować CLASSPATH i PATHodpowiednio zmienne. Tutaj ustawimy go tylko dla pliku log4j.xxxjar.

$ pwd
/usr/local/apache-log4j-1.2.15
$ export CLASSPATH= \
      $CLASSPATH:/usr/local/apache-log4j-1.2.15/log4j-1.2.15.jar
$ export PATH=$PATH:/usr/local/apache-log4j-1.2.15/

Log4j API opiera się na architekturze warstwowej, w której każda warstwa udostępnia różne obiekty do wykonywania różnych zadań. Ta warstwowa architektura sprawia, że ​​projekt jest elastyczny i łatwy do rozszerzenia w przyszłości.

We frameworku log4j dostępne są dwa typy obiektów.

• Core Objects:Są to obowiązkowe obiekty ram. Są zobowiązani do korzystania z frameworka.

• Support Objects:Są to opcjonalne obiekty frameworka. Obsługują podstawowe obiekty do wykonywania dodatkowych, ale ważnych zadań.

Podstawowe obiekty

Podstawowe obiekty obejmują następujące typy obiektów:

Obiekt rejestratora

Warstwa najwyższego poziomu to Logger, który udostępnia obiekt Logger. Obiekt Logger jest odpowiedzialny za przechwytywanie informacji logowania i są one przechowywane w hierarchii przestrzeni nazw.

Obiekt układu

Warstwa układu zawiera obiekty używane do formatowania informacji rejestrowania w różnych stylach. Zapewnia obsługę obiektów dołączających przed opublikowaniem informacji logowania.

Obiekty układu odgrywają ważną rolę w publikowaniu informacji logowania w sposób czytelny dla człowieka i nadający się do ponownego wykorzystania.

Appender Object

Jest to warstwa niższego poziomu, która udostępnia obiekty Appender. Obiekt Appender jest odpowiedzialny za publikowanie informacji logowania w różnych preferowanych miejscach docelowych, takich jak baza danych, plik, konsola, UNIX Syslog itp.

Poniższy diagram wirtualny przedstawia komponenty frameworka log4J:

Obiekty wsparcia

Istnieją inne ważne obiekty we frameworku log4j, które odgrywają istotną rolę w strukturze rejestrowania:

Obiekt poziomu

Obiekt Level definiuje szczegółowość i priorytet wszelkich informacji rejestrowanych. Istnieje siedem poziomów rejestrowania zdefiniowanych w API: OFF, DEBUG, INFO, ERROR, WARN, FATAL i ALL.

Filtruj obiekt

Obiekt Filter służy do analizowania informacji logowania i podejmowania dalszych decyzji, czy te informacje powinny być rejestrowane, czy nie.

Z obiektami Appender może być skojarzonych kilka obiektów Filter. Jeśli informacje rejestrowania są przekazywane do określonego obiektu Appender, wszystkie obiekty filtru skojarzone z tym Appender muszą zatwierdzić informacje rejestrowania, zanim będzie można je opublikować w dołączonym miejscu docelowym.

ObjectRenderer

Obiekt ObjectRenderer specjalizuje się w dostarczaniu reprezentacji String różnych obiektów przekazywanych do struktury rejestrowania. Ten obiekt jest używany przez obiekty Layout do przygotowania ostatecznych informacji logowania.

LogManager

Obiekt LogManager zarządza strukturą rejestrowania. Odpowiada za odczyt początkowych parametrów konfiguracyjnych z ogólnosystemowego pliku konfiguracyjnego lub klasy konfiguracyjnej.

W poprzednim rozdziale wyjaśniono podstawowe komponenty log4j. W tym rozdziale wyjaśniono, w jaki sposób można skonfigurować podstawowe komponenty za pomocą pliku konfiguracyjnego. Konfiguracja log4j obejmuje przypisanie poziomu, zdefiniowanie Appendera i określenie obiektów układu w pliku konfiguracyjnym.

Plik log4j.properties jest plikiem konfiguracyjnym log4j, w którym właściwości są przechowywane w parach klucz-wartość. Domyślnie LogManager szuka pliku o nazwie log4j.properties wCLASSPATH.

• Poziom głównego programu rejestrującego jest zdefiniowany jako DEBUG. DEBUG dołącza do niego program dołączający o nazwie X.

• Ustaw program dołączający o nazwie X, aby był prawidłowym programem dołączającym.

• Ustaw układ dla dołączającego X.

log4j.properties Składnia:

Poniżej przedstawiono składnię pliku log4j.properties dla programu dołączającego X:

# Define the root logger with appender X
log4j.rootLogger = DEBUG, X

# Set the appender named X to be a File appender
log4j.appender.X=org.apache.log4j.FileAppender

# Define the layout for X appender
log4j.appender.X.layout=org.apache.log4j.PatternLayout
log4j.appender.X.layout.conversionPattern=%m%n

log4j.properties Przykład

Korzystając z powyższej składni, definiujemy w pliku log4j.properties :

• Poziom głównego programu rejestrującego jest zdefiniowany jako DEBUG, a program dołączający DEBUG o nazwie FILE.

• Plik appender FILE jest zdefiniowany jako org.apache.log4j.FileAppender . Zapisuje do pliku o nazwie „log.out” znajdującego się wlog informator.

• Zdefiniowany wzorzec układu to % m% n , co oznacza, że ​​po wydrukowanym komunikacie logowania nastąpi znak nowej linii.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Należy zauważyć, że log4j obsługuje podstawianie zmiennych w stylu UNIX, na przykład $ {nazwa_zmiennej}.

Poziom debugowania

Użyliśmy DEBUG z obydwoma aplikatorami. Wszystkie możliwe opcje to:

• TRACE
• DEBUG
• INFO
• WARN
• ERROR
• FATAL
• ALL

Te poziomy zostałyby wyjaśnione w log4j Logging Levels .

Appenders

Apache log4j udostępnia obiekty Appender, które są głównie odpowiedzialne za drukowanie komunikatów logowania do różnych miejsc docelowych, takich jak konsole, pliki, gniazda, dzienniki zdarzeń NT itp.

Z każdym obiektem Appender są skojarzone różne właściwości, które wskazują zachowanie tego obiektu.

własność	Opis
układ	Program Appender używa obiektów układu i skojarzonego z nimi wzorca konwersji do formatowania informacji rejestrowania.
cel	Celem może być konsola, plik lub inny element w zależności od dodającego.
poziom	Poziom jest wymagany do kontrolowania filtrowania komunikatów dziennika.
próg	Z aplikatorem może być powiązany poziom progowy niezależny od poziomu programu rejestrującego. Appender ignoruje wszelkie komunikaty rejestrowania, które mają poziom niższy niż poziom progowy.
filtr	Obiekty filtru mogą analizować informacje rejestrowania poza dopasowaniem poziomu i decydować, czy żądania rejestrowania powinny być obsługiwane przez określony program Appender, czy ignorowane.

Możemy dodać obiekt Appender do Loggera, dołączając następujące ustawienie do pliku konfiguracyjnego za pomocą następującej metody:

log4j.logger.[logger-name]=level, appender1,appender..n

Możesz napisać tę samą konfigurację w formacie XML w następujący sposób:

<logger name="com.apress.logging.log4j" additivity="false">
   <appender-ref ref="appender1"/>
   <appender-ref ref="appender2"/>
</logger>

Jeśli chcesz dodać obiekt Appender do swojego programu, możesz użyć następującej metody:

public void addAppender(Appender appender);

Metoda addAppender () dodaje Appender do obiektu Logger. Jak pokazuje przykładowa konfiguracja, możliwe jest dodanie wielu obiektów programu Appender do programu rejestrującego w postaci listy oddzielonej przecinkami, a każdy z nich drukuje informacje rejestrowania w osobnych miejscach docelowych.

W powyższym przykładzie użyliśmy tylko jednego programu Appender FileAppender . Wszystkie możliwe opcje dołączającego to:

• AppenderSkeleton
• AsyncAppender
• ConsoleAppender
• DailyRollingFileAppender
• ExternallyRolledFileAppender
• FileAppender
• JDBCAppender
• JMSAppender
• LF5Appender
• NTEventLogAppender
• NullAppender
• RollingFileAppender
• SMTPAppender
• SocketAppender
• SocketHubAppender
• SyslogAppender
• TelnetAppender
• WriterAppender

Omówilibyśmy FileAppender w logowaniu do plików, a JDBC Appender byłby objęty logowaniem w bazie danych .

Układ

Użyliśmy PatternLayout z naszym appenderem. Wszystkie możliwe opcje to:

• DateLayout
• HTMLLayout
• PatternLayout
• SimpleLayout
• XMLLayout

Używając HTMLLayout i XMLLayout, możesz wygenerować dziennik w formacie HTML, a także w formacie XML.

Formatowanie układu

Dowiesz się, jak sformatować komunikat dziennika w rozdziale: Formatowanie dziennika .

Widzieliśmy, jak utworzyć plik konfiguracyjny. W tym rozdziale opisano sposób generowania komunikatów debugowania i rejestrowania ich w prostym pliku tekstowym.

Poniżej znajduje się prosty plik konfiguracyjny utworzony dla naszego przykładu. Zrewidujmy to jeszcze raz:

• Poziom głównego programu rejestrującego jest zdefiniowany jako DEBUG i dołącza do niego program dołączający o nazwie PLIK.

• Plik appender PLIK jest zdefiniowany jako org.apache.log4j.FileAppender i zapisuje do pliku o nazwie „log.out” znajdującego się w log informator.

• Zdefiniowany wzorzec układu to% m% n, co oznacza, że ​​po wydrukowanym komunikacie logowania nastąpi znak nowej linii.

Zawartość pliku log4j.properties jest następująca:

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Korzystanie z log4j w programie Java

Poniższa klasa Java jest bardzo prostym przykładem, który inicjuje, a następnie używa biblioteki rejestrowania Log4J dla aplikacji Java.

import org.apache.log4j.Logger;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

Skompiluj i wykonaj

Oto kroki, aby skompilować i uruchomić wyżej wymieniony program. Upewnij się, że masz ustawionePATH i CLASSPATH odpowiednio przed przystąpieniem do kompilacji i wykonania.

Wszystkie biblioteki powinny być dostępne w CLASSPATHa plik log4j.properties powinien być dostępny w PATH. Postępuj zgodnie z instrukcjami podanymi poniżej:

• Utwórz plik log4j.properties, jak pokazano powyżej.

• Utwórz plik log4jExample.java, jak pokazano powyżej, i skompiluj go.

• Uruchom plik binarny log4jExample, aby uruchomić program.

Otrzymasz następujący wynik w pliku /usr/home/log4j/log.out:

Hello this is a debug message
Hello this is an info message

Klasa Logger udostępnia różne metody obsługi działań związanych z rejestrowaniem. Klasa Logger nie pozwala nam na utworzenie nowej instancji Loggera, ale udostępnia dwie statyczne metody uzyskiwania obiektu Logger:

• public static Logger getRootLogger();
• public static Logger getLogger(String name);

Pierwsza z dwóch metod zwraca główny program rejestrujący instancji aplikacji i nie ma nazwy.

Każda inna nazwana instancja obiektu Logger jest uzyskiwana za pomocą drugiej metody, przekazując nazwę programu rejestrującego. Nazwą loggera może być dowolny ciąg, który możesz podać, zwykle nazwa klasy lub pakietu, jak używaliśmy w ostatnim rozdziale i jest to wspomniane poniżej:

static Logger log = Logger.getLogger(log4jExample.class.getName());

Metody logowania

Po uzyskaniu wystąpienia nazwanego programu rejestrującego możemy użyć kilku metod rejestratora do rejestrowania komunikatów. Klasa Logger ma następujące metody drukowania informacji rejestrowania.

Sr.No	Metody i opis
1	public void debug(Object message) Wyświetla komunikaty z poziomem Level.DEBUG.
2	public void error(Object message) Wyświetla komunikaty z poziomem Level.ERROR.
3	public void fatal(Object message); Wyświetla komunikaty z poziomem Level.FATAL.
4	public void info(Object message); Drukuje wiadomości z poziomem Level.INFO.
5	public void warn(Object message); Wyświetla komunikaty z poziomem Level.WARN.
6	public void trace(Object message); Drukuje komunikaty z poziomem Level.TRACE.

Wszystkie poziomy są zdefiniowane w klasie org.apache.log4j.Level, a każdą z wyżej wymienionych metod można wywołać w następujący sposób:

import org.apache.log4j.Logger;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Kiedy kompilujesz i uruchamiasz program LogClass, wygeneruje on następujący wynik:

Debug Message!
Info Message!
Warn Message!
Error Message!
Fatal Message!

Wszystkie komunikaty debugowania mają więcej sensu, gdy są używane w połączeniu z poziomami. Poziomy omówimy w następnym rozdziale, a następnie będziesz dobrze rozumieć, jak używać tych metod w połączeniu z różnymi poziomami debugowania.

Klasa org.apache.log4j.Level udostępnia następujące poziomy. Możesz także zdefiniować własne poziomy, klasyfikując podklasy Level.

Poziom	Opis
WSZYSTKO	Wszystkie poziomy, w tym poziomy niestandardowe.
ODPLUSKWIĆ	Wyznacza szczegółowe zdarzenia informacyjne, które są najbardziej przydatne do debugowania aplikacji.
INFO	Wyznacza komunikaty informacyjne, które podkreślają postęp aplikacji na gruboziarnistym poziomie.
OSTRZEC	Oznacza potencjalnie szkodliwe sytuacje.
BŁĄD	Wyznacza zdarzenia błędów, które mogą nadal umożliwiać kontynuowanie działania aplikacji.
FATALNY	Oznacza bardzo poważne błędy, które prawdopodobnie doprowadzą do przerwania działania aplikacji.
POZA	Najwyższa możliwa ranga i ma na celu wyłączenie logowania.
ŚLAD	Wyznacza bardziej szczegółowe zdarzenia informacyjne niż DEBUG.

Jak działają poziomy?

Żądanie dziennika poziomu p w loggerze z poziomicą qjest włączone, jeśli p> = q. Ta zasada leży u podstaw log4j. Zakłada, że ​​poziomy są uporządkowane. Dla poziomów standardowych mamy ALL <DEBUG <INFO <WARN <ERROR <FATAL <OFF.

Poniższy przykład pokazuje, jak możemy filtrować wszystkie nasze komunikaty DEBUG i INFO. Ten program używa metody rejestratora setLevel (Level.X) do ustawienia żądanego poziomu rejestrowania:

W tym przykładzie zostaną wydrukowane wszystkie wiadomości z wyjątkiem debugowania i informacji:

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.setLevel(Level.WARN);

      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Kiedy kompilujesz i uruchamiasz program LogClass, wygeneruje on następujący wynik:

Warn Message!
Error Message!
Fatal Message!

Ustawianie poziomów za pomocą pliku konfiguracyjnego

log4j zapewnia ustawienie poziomu oparte na pliku konfiguracyjnym, które uwalnia Cię od zmiany kodu źródłowego, gdy chcesz zmienić poziom debugowania.

Poniżej znajduje się przykładowy plik konfiguracyjny, który wykonywałby to samo zadanie, co przy użyciu metody log.setLevel (Level.WARN) w powyższym przykładzie.

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = WARN, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Skorzystajmy teraz z naszego następującego programu:

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

Teraz skompiluj i uruchom powyższy program, a otrzymasz następujący wynik w pliku /usr/home/log4j/log.out:

Warn Message!
Error Message!
Fatal Message!

Apache log4j udostępnia różne obiekty układu, z których każdy może formatować dane logowania według różnych układów. Możliwe jest również utworzenie obiektu Layout, który formatuje dane logowania w sposób specyficzny dla aplikacji.

Wszystkie obiekty Layout otrzymują obiekt LoggingEvent z obiektów Appender. Obiekty Layout następnie pobierają argument komunikatu z LoggingEvent i stosują odpowiedni ObjectRenderer w celu uzyskania reprezentacji String komunikatu.

Typy układów

Klasą najwyższego poziomu w hierarchii jest klasa abstrakcyjna org.apache.log4j.Layout. Jest to klasa bazowa dla wszystkich innych klas układu w interfejsie API log4j.

Klasa Layout jest definiowana jako abstrakcyjna w aplikacji, nigdy nie używamy tej klasy bezpośrednio; zamiast tego pracujemy z jego podklasami, które są następujące:

• DateLayout

• HTMLLayout

• PatternLayout.

• SimpleLayout

• XMLLayout

Metody układu

Ta klasa zapewnia szkieletową implementację wszystkich typowych operacji we wszystkich innych obiektach Layout i deklaruje dwie metody abstrakcyjne.

Sr.No.	Metody i opis
1	public abstract boolean ignoresThrowable() Wskazuje, czy informacje rejestrowania obsługują dowolny obiekt java.lang.Throwable przekazany do niego w ramach zdarzenia rejestrowania. Jeśli obiekt Layout obsługuje obiekt Throwable, to obiekt Layout nie ignoruje go i zwraca wartość false.
2	public abstract String format(LoggingEvent event) Poszczególne podklasy układu implementują tę metodę do formatowania określonego układu.

Oprócz tych metod abstrakcyjnych klasa Layout zapewnia konkretną implementację dla metod wymienionych poniżej:

Sr.No.	Metody i opis
1	public String getContentType() Zwraca typ zawartości używany przez obiekty Layout. Klasa bazowa zwraca tekst / zwykły jako domyślny typ zawartości.
2	public String getFooter() Określa stopkę komunikatu logowania.
3	public String getHeader() Określa informacje nagłówka komunikatu logowania.

Każda podklasa może zwracać informacje specyficzne dla klasy, zastępując konkretną implementację tych metod.

Aby zapisać swoje dane logowania do pliku, musiałbyś użyć org.apache.log4j.FileAppender .

Konfiguracja FileAppender

FileAppender ma następujące konfigurowalne parametry:

własność	Opis
directFlush	Ta flaga jest domyślnie ustawiona na true, co oznacza, że ​​strumień wyjściowy do pliku jest opróżniany przy każdej operacji dołączania.
kodowanie	Możliwe jest użycie dowolnego kodowania znaków. Domyślnie jest to schemat kodowania specyficzny dla platformy.
próg	Poziom progowy dla tego dołączającego.
Nazwa pliku	Nazwa pliku dziennika.
fileAppend	Jest to domyślnie ustawione na true, co oznacza, że ​​informacje rejestrowania są dołączane na końcu tego samego pliku.
bufferedIO	Ta flaga wskazuje, czy musimy włączyć zapisywanie buforowane. Domyślnie jest ustawiona na false.
Rozmiar bufora	Jeśli buforowane we / wy jest włączone, wskazuje rozmiar bufora. Domyślnie jest to 8kb.

Poniżej znajduje się przykładowy plik konfiguracyjny log4j.properties dla programu FileAppender.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, overwrite
log4j.appender.FILE.Append=false

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Jeśli chcesz mieć plik konfiguracyjny XML odpowiadający powyższemu plikowi log4j.properties , oto treść:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="FILE" class="org.apache.log4j.FileAppender">
   <param name="file" value="${log}/log.out"/>
   <param name="immediateFlush" value="true"/>
   <param name="threshold" value="debug"/>
   <param name="append" value="false"/>
   <layout class="org.apache.log4j.PatternLayout">
      <param name="conversionPattern" value="%m%n"/>
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="FILE"/>
</logger>

</log4j:configuration>

Możesz spróbować log4j - przykładowy program z powyższą konfiguracją.

Logowanie do wielu plików

Z pewnych powodów możesz chcieć zapisywać komunikaty dziennika w wielu plikach, na przykład jeśli rozmiar pliku osiągnął określony próg.

Aby zapisać informacje logowania w wielu plikach, należałoby użyć klasy org.apache.log4j.RollingFileAppender, która rozszerza klasę FileAppender i dziedziczy wszystkie jej właściwości.

Oprócz wymienionych powyżej dla FileAppender mamy następujące konfigurowalne parametry:

własność	Opis
maxFileSize	Jest to krytyczny rozmiar pliku, powyżej którego plik zostanie przeniesiony. Wartość domyślna to 10 MB.
maxBackupIndex	Ta właściwość określa liczbę plików kopii zapasowych, które mają zostać utworzone. Wartość domyślna to 1.

Poniżej znajduje się przykładowy plik konfiguracyjny log4j.properties dla RollingFileAppender.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.RollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the maximum file size before rollover
log4j.appender.FILE.MaxFileSize=5MB

# Set the the backup index
log4j.appender.FILE.MaxBackupIndex=2

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Jeśli chcesz mieć plik konfiguracyjny XML, możesz wygenerować taki sam, jak wspomniano w sekcji początkowej i dodać tylko dodatkowe parametry związane z RollingFileAppender .

Ta przykładowa konfiguracja pokazuje, że maksymalny dopuszczalny rozmiar każdego pliku dziennika to 5 MB. Po przekroczeniu maksymalnego rozmiaru zostanie utworzony nowy plik dziennika. Ponieważ parametr maxBackupIndex jest zdefiniowany jako 2, gdy drugi plik dziennika osiągnie maksymalny rozmiar, pierwszy plik dziennika zostanie usunięty, a następnie wszystkie informacje rejestrowania zostaną przywrócone do pierwszego pliku dziennika.

Możesz spróbować log4j - przykładowy program z powyższą konfiguracją.

Codzienne generowanie plików dziennika

Może istnieć wymóg codziennego generowania plików dziennika, aby zachować czysty zapis informacji logowania.

Aby codziennie zapisywać informacje logowania do plików, należałoby użyć klasy org.apache.log4j.DailyRollingFileAppender, która rozszerza klasę FileAppender i dziedziczy wszystkie jej właściwości.

Oprócz wymienionych powyżej dla FileAppender istnieje tylko jeden ważny parametr konfigurowalny:

własność	Opis
DatePattern	Wskazuje, kiedy należy przesunąć plik i jaką konwencję nazewnictwa należy zastosować. Domyślnie przewijanie jest wykonywane codziennie o północy.

DatePattern kontroluje harmonogram przewijania przy użyciu jednego z następujących wzorców:

DatePattern	Opis
'.' rrrr-MM	Przewiń na koniec każdego miesiąca i na początku następnego miesiąca.
'.' rrrr-MM-dd	Przewracaj się o północy każdego dnia. To jest wartość domyślna.
'.' rrrr-MM-dd-a	Przewróć w południe i o północy każdego dnia.
'.' rrrr-MM-dd-HH	Przewracaj się w górnej części każdej godziny.
'.' rrrr-MM-dd-GG-mm	Przewracaj się co minutę.
'.' rrrr-ww	Przewiń na pierwszy dzień każdego tygodnia, w zależności od lokalizacji.

Poniżej znajduje się przykładowy plik konfiguracyjny log4j.properties do generowania plików dziennika przewijanych w południe i o północy każdego dnia.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the DatePattern
log4j.appender.FILE.DatePattern='.' yyyy-MM-dd-a

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

Jeśli chcesz mieć plik konfiguracyjny XML, możesz wygenerować taki sam, jak wspomniano w sekcji początkowej i dodać tylko dodatkowe parametry związane z DailyRollingFileAppender .

Możesz spróbować log4j - przykładowy program z powyższą konfiguracją.

Interfejs API log4j udostępnia obiekt org.apache.log4j.jdbc.JDBCAppender , który może umieszczać informacje logowania w określonej bazie danych.

Konfiguracja JDBCAppender

własność	Opis
Rozmiar bufora	Ustawia rozmiar bufora. Domyślny rozmiar to 1.
kierowca	Ustawia klasę sterownika na określony ciąg. Jeśli nie określono żadnej klasy sterownika, domyślnie sun.jdbc.odbc.JdbcOdbcDriver.
układ	Ustawia używany układ. Domyślny układ to org.apache.log4j.PatternLayout.
hasło	Ustawia hasło bazy danych.
sql	Określa instrukcję SQL, która ma być wykonywana za każdym razem, gdy wystąpi zdarzenie rejestrowania. Może to być INSERT, UPDATE lub DELETE.
URL	Ustawia adres URL JDBC.
użytkownik	Ustawia nazwę użytkownika bazy danych.

Konfiguracja tabeli dziennika

Przed rozpoczęciem korzystania z rejestrowania opartego na JDBC należy utworzyć tabelę, aby zachować wszystkie informacje dziennika. Poniżej znajduje się instrukcja SQL do tworzenia tabeli LOGS:

CREATE TABLE LOGS
   (USER_ID VARCHAR(20) NOT NULL,
    DATED   DATE NOT NULL,
    LOGGER  VARCHAR(50) NOT NULL,
    LEVEL   VARCHAR(10) NOT NULL,
    MESSAGE VARCHAR(1000) NOT NULL
   );

Przykładowy plik konfiguracyjny

Poniżej znajduje się przykładowy plik konfiguracyjny log4j.properties dla JDBCAppender, który będzie używany do rejestrowania komunikatów w tabeli LOGS.

# Define the root logger with appender file
log4j.rootLogger = DEBUG, DB

# Define the DB appender
log4j.appender.DB=org.apache.log4j.jdbc.JDBCAppender

# Set JDBC URL
log4j.appender.DB.URL=jdbc:mysql://localhost/DBNAME

# Set Database Driver
log4j.appender.DB.driver=com.mysql.jdbc.Driver

# Set database user name and password
log4j.appender.DB.user=user_name
log4j.appender.DB.password=password

# Set the SQL statement to be executed.
log4j.appender.DB.sql=INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')

# Define the layout for file appender
log4j.appender.DB.layout=org.apache.log4j.PatternLayout

W przypadku bazy danych MySQL musiałbyś użyć rzeczywistej nazwy DBNAME, identyfikatora użytkownika i hasła, w którym utworzyłeś tabelę LOGS. Instrukcja SQL ma na celu wykonanie instrukcji INSERT z nazwą tabeli LOGS i wartościami, które mają być wprowadzone do tabeli.

JDBCAppender nie wymaga jawnego definiowania układu. Zamiast tego instrukcja SQL przekazana do niej używa PatternLayout.

Jeśli chcesz mieć plik konfiguracyjny XML odpowiadający powyższemu plikowi log4j.properties , oto treść:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="DB" class="org.apache.log4j.jdbc.JDBCAppender">
   <param name="url" value="jdbc:mysql://localhost/DBNAME"/>
   <param name="driver" value="com.mysql.jdbc.Driver"/>
   <param name="user" value="user_id"/>
   <param name="password" value="password"/>
   <param name="sql" value="INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')"/>
   <layout class="org.apache.log4j.PatternLayout">
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="DB"/>
</logger>

</log4j:configuration>

Przykładowy program

Poniższa klasa Java jest bardzo prostym przykładem, który inicjuje, a następnie używa biblioteki rejestrowania Log4J dla aplikacji Java.

import org.apache.log4j.Logger;
import java.sql.*;
import java.io.*;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Debug");
      log.info("Info");
   }
}

Skompiluj i wykonaj

Oto kroki, aby skompilować i uruchomić wyżej wymieniony program. Upewnij się, że masz ustawionePATH i CLASSPATH odpowiednio przed przystąpieniem do kompilacji i wykonania.

Wszystkie biblioteki powinny być dostępne w CLASSPATHa plik log4j.properties powinien być dostępny w PATH. Postępuj zgodnie z podanymi krokami:

• Utwórz plik log4j.properties, jak pokazano powyżej.
• Utwórz plik log4jExample.java, jak pokazano powyżej, i skompiluj go.
• Uruchom plik binarny log4jExample, aby uruchomić program.

Teraz sprawdź swoją tabelę LOGS w bazie danych DBNAME, a znajdziesz następujące wpisy:

mysql >  select * from LOGS;
+---------+------------+--------------+-------+---------+
| USER_ID | DATED      | LOGGER       | LEVEL | MESSAGE |
+---------+------------+--------------+-------+---------+
|         | 2010-05-13 | log4jExample | DEBUG | Debug   |
|         | 2010-05-13 | log4jExample | INFO  | Info    |
+---------+------------+--------------+-------+---------+
2 rows in set (0.00 sec)

Note:Tutaj x służy do wyprowadzania zagnieżdżonego kontekstu diagnostycznego (NDC) skojarzonego z wątkiem, który wygenerował zdarzenie rejestrowania. Używamy NDC do rozróżniania klientów w komponentach po stronie serwera obsługujących wielu klientów. Sprawdź podręcznik Log4J, aby uzyskać więcej informacji na ten temat.