Naplózás Javában

Kategória: Java külső könyvtárak.

Áttekintés

A naplózás (kapcsolódó fogalmak angolul log, logging, logfile; gyakran magyarul is logolásnak ill. logfájlnak hívjuk) azt jelenti, hogy a program futása során bizonyos üzeneteket kiírunk. Ennek számos oka lehet: egyrészt hogy lássuk, egyáltalán fut-e a program (sokkal megnyugtatóbb, ha futás során írogat ezt-azt, mintha csak a fekete képernyőt látnánk), vannak-e enne hibák, ill. szükség esetén jelentősen megkönnyíti a hibakeresést. A naplózást általában fájlba írjuk, és a legelső, amit egy hiba keresése során végrehajtunk az az, hogy megnézzük a naplófájlt. És tegyük azt is hozzá, hogy a hibák szinte természetes részei a szoftvernek, hibamentes szoftver nem létezik. Egy napló bejegyzés tartalma rendszertől függetlenül nagy vonalakban a következő:

  • időpont,
  • forrásfájl teljes elérési útvonallal, azon belül sor,
  • osztálynév, eljárás neve,
  • változók, paraméterek aktuális értéke,
  • többszálú programok esetén a szál azonosítója.

Ugyancsak rendszertől függetlenül az alábbi döntéseket kell meghoznunk:

  • Egészen pontosan miket írjon ki a fentiekből. Kell mind? Hell valami más is?
  • Mikor mit írjon ki. A naplózásnak vannak szintjei:
    • ERROR Lehet azt kérni, hogy csak a hibákat írja ki; azon belül is csak a fatális hibákat (FATAL, ami után a program megáll), vagy minden hibát.
    • INFO A hibákon túl bizonyos információkat is, pl. hogy elindult a program stb.
    • DEBUG Hibakereséshez kapcsolódó alap információkat is írjon ki, pl. egyes eljárások belépési pontjai, vagy bizonyos fontosabb változók pillanatnyi értékei.
    • TRACE Annyi információt írjon ki, amivel teljes nyomkövetést biztosít, beleértve akár a nagyobb struktúrák belsejét.
  • Mindezt konfigurálhatóvá szeretnénk tenni, pl. a fejlesztői vagy teszt környezetben több információt szeretnénk kiíratni, produkciós környezetben kevesebbet.
  • Egy idő után rájövünk, hogy érdemes lenne olyan szinten is konfigurálhatóvá tenni, hogy komponensenként meg tudjuk mondani, melyik mennyit naplózzon. Pl. egy hibakeresés kapcsán, reprodukáláskor az érintett komponensek esetén célszerű a nyomkövetést is bekapcsolni, a többi esetén viszont csak a normál hibakeresést, melynek oka az, hogy a kiírt adat mennyisége exponenciálisan növekszik a szintekkel, és a túl sok irreleváns adat gátolja a hibakeresést.
  • Tovább gondolva: azt is meg szeretnénk mondani, hogy fájlba írja-e a napló bejegyzéseket vagy konzolra, esetleg mindkettőre. Ill. azt is, hogy pontosan mit szeretnénk fájlba írni és mit konzolra, pl. konzolja csak alap információkat (elindult a program, hiba történt stb.), míg fájlba több mindent.

Van pár funkció, melyre egy méreten túl tetszőleges megvalósítás során gondolni kell:

  • A gyakorlat azt mutatja, hogy a naplófájlok igen nagyra tudnak hízni, ezt valahogyan kezelni kell. Pl. ha a fájl elér egy bizonyos méretet, akkor kezdjen úgy naplófájlt, a régieket automatikusan archiválja (a tömörítés naplófájlok esetén különösen hatékony!) vagy törölje.
  • Az úgynevezett flush mechanizmusra is gondolnunk kell, ami a következőt jelenti. A fájlba írás úgy általában drága művelet: meg kell nyitni a fájlt, majd miután fizikailag is belekerült az adat, le kell zárnunk. Ehelyett sokkal hatékonyabb az, ha a memóriában gyűjtjük az információt, majd egyszerre több mindent kiírunk. Igen ám, csakhogy ha váratlanul megáll a program, akkor az utolsó szelet (ami a memóriában van, de még nincs kimentve) elveszik, és hibakeresés szempontjából ez a leglényegesebb rész: mi történt pontosan akkor, ami a hibát kiváltotta. A naplózás során erre is gondolni kell.
  • A programozás során meg kell tudnunk adni minden lényeges információt, pl. adott esetben megfelelően formázott paramétereket.

Látható tehát, hogy teljesen általános problémák vetődnek fel, amelyek minden valamirevaló programnál jelentkeznek. Így jogosan feltételezhetjük, hogy az idők során erre kialakultak szabványok, és ez így igaz. A Java esetén létezik egy Java Logging API az 1.4-es verzió óta, ezt a gyakorlatban viszont szinte sohasem használjuk, hisz nekünk kell megírnunk hozzá a formázót és a kiírót is. Részletesen emiatt ezzel most nem foglalkozunk; jó cikkek születtek a témában, amit az alfejezet végén, az összefoglalónál megadok. Viszont fent láthattuk, hogy a megoldandó problémák is teljesen általánosak, így számomra teljesen érthetetlen, hogy egy olyan gazdag programozási nyelv esetén, mint a Java, miért nem lett a formázás és kiírás is szabvány része. Hosszú ideig kvázi-szabványnak volt tekinthető a log4j.

Egy "gyalogos" példa

Lássunk egy egyszerű példát, melyet a https://www.mkyong.com/logging/log4j-hello-world-example/ leírás alapján állítottam össze! Ehhez a példához - ahogy mindegyikhez ezen az oldalon - külső könyvtárra van szükség. Ezt elvileg számos forrásból beszerezhetjük: magától a fejlesztő cégtől; ha meg van a forrása, mi magunk is lefordíthatjuk; valamint léteznek olyan oldalak, ahol számos ilyen könyvtár megtalálható. (Ez utóbbit egyébként artifactory-knak hívjuk az artifact dictionay szavakból.) Az egyik legnépszerűbb ilyen gyűjtemény oldal a Maven Repository, ami elérhető a https://mvnrepository.com oldalon. Ezen az oldalon egyébként csak olyan könyvtárakról lesz szó, amelyek kellően általánosak ahhoz, hogy szerepeljenek ebben a gyűjteményben.

Egy ilyen könyvtár beazonosításához 3 dologra van szükség:

  • GroupID: ez általában a gyártót jelöli (de amúgy bármi lehet).
  • ArtifactID: ez maga a könyvtár.
  • Version: a pontos, általában 3 szintű verzió.

Jelen esetben az alábbit fogjuk használni:

  • GroupID: log4j
  • ArtifactID: log4j
  • Version: 1.2.17

Ezt kell tehát beszereznünk, jelen esetben célszerűen letöltenünk a Maven Repository oldalról, azon belül innen: https://mvnrepository.com/artifact/log4j/log4j/1.2.17. (Tipp: ha a Google keresőbe beírjuk a kulcsszavakat, jelen esetben pl azt, hogy "log4j jar" akkor szinte biztos, hogy ez lesz az első találat.) Ott kattintsunk a Files sorban található bundle-re (közvetlen link: https://repo1.maven.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.jar) és töltsük le. Ugyanabba a könyvtárba, ahova letöltöttük, valósítsuk meg a programot, pl. így:

import org.apache.log4j.Logger;
 
public class Main {
    private static Logger logger = Logger.getLogger(Main.class);
 
    public static void main(String[] args) {
        logger.info("Start of the main function.");
        logger.debug("This is a debug message");
    }
 
}

Az első sorban a használt osztály, mégpedig a org.apache.log4j.Logger importálása történik meg. (Ami egyébként valójában nem tölt be semmit, csak megjelöli a fordítónak, hogy hol található. Erről még később részletesebben lesz szó.) A naplózáshoz létrehozunk egy statikus Logger példányt az adott osztályt (nem objektumot!) átadva paraméterül, majd azon tudjuk meghívni a megfelelő eljárásokat, pl. a példában az info() vagy debug(). (Érdemes megnézni az eljárások listáját, melyet itt nem részletezek.) A példa két sort ír ki: az egyiket információ szinten, a másikat pedig hibakeresés szinten.

Azt, hogy ténylegesen hova írja a napló bejegyzéseket, és milyen formában, konfigurációs fájl segítségével adhatjuk meg. Hozzunk létre egy log4j.properties nevű szöveg fájlt ezzel a tartalommal:

# Root logger option
log4j.rootLogger=DEBUG, stdout, file

# Redirect log messages to console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.Threshold=INFO
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Redirect log messages to a log file, support file rolling
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=logger-application.log
log4j.appender.file.MaxFileSize=5MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

A konfiguráció értelmezése a következő:

  • Az első sorban alapértelmezettre teszi a DEBUG (hibakeresés) szintet, és definiál két célt: stdout és file.
  • A következő szakasz definiálja a stdout-ot:
    • konzolja írja,
    • felüldefiniálja a naplózási szintet (csak az INFO és magasabb prioritású bejegyzéseket írja ki, a DEBUG üzeneteket nem),
    • megadja a formáját: először a dátumot írja ki, majd a naplózási szintet (5 karakter szélesen, hogy függőlegesen igazítva legyen), utána a forrásfájl nevét, mast annak sornak a számát, ahol a naplóbejegyzés van, végül magát a bejegyzést.
  • A második nagy szakasz pedig a fájlba írást definiálja:
    • megadja, hogy olyan legyen a kiírási stratégia, hogy felülírja legrégebbit (RollingFileAppender),
    • megadja a fájl nevét,
    • beállítja, hogy a maximális fájlméret 5 MB lehet, és legfeljebb 10 naplófájlt ment el,
    • beállítja ugyanazt a formátumot.

Összefoglalva, ebben a pillanatban 3 fájunk van, ugyanabban a könyvtárban:

  • log4j-1.2.17.jar: ez definiálja a naplózáshoz szükséges osztályokat. Ilyen egyébként ezen az oldalon mindegyik program esetén lesz.
  • Main.java: ez a mi forrásunk.
  • log4j.properties: konfigurációs fájl. Ez specifikus a log4j-1.2.17.jar könyvtárra.

A következő lépés a fordítás. Ha megpróbáljuk a szokásos módon, javac Main.java paranccsal lefordítani, az alábbi hibaüzenetet kapjuk:

> javac Main.java
Main.java:1: error: package org.apache.log4j does not exist
import org.apache.log4j.Logger;
                       ^
Main.java:4: error: cannot find symbol
    private static Logger logger = Logger.getLogger(Main.class);
                   ^
  symbol:   class Logger
  location: class Main
Main.java:4: error: cannot find symbol
    private static Logger logger = Logger.getLogger(Main.class);
                                   ^
  symbol:   variable Logger
  location: class Main
3 errors

A fordításhoz meg kell adni azt, hogy melyik könyvtárban keresse a org.apache.log4j.Logger osztályt, amit az osztály elérési útvonal (classpath) megadásával tudjuk megtenni, a következőképpen:

javac -classpath log4j-1.2.17.jar Main.java

Ezt a következőképpen is rövidíthetjük:

javac -cp log4j-1.2.17.jar Main.java

Ha szokásosan próbáljuk futtatni (java Main), akkor is hibába ütközünk:

>java Main
Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/log4j/Logger
        at Main.<clinit>(Main.java:4)
Caused by: java.lang.ClassNotFoundException: org.apache.log4j.Logger
        at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:583)
        at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
        at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
        ... 1 more

Itt is meg kell adni az osztály elérési útvonalban a log4j-1.2.17.jar könyvtárat. Ha a fenti módon próbálkoznánk, akkor ismét hibába futunk bele (nem egyszerű!):

>java -cp log4j-1.2.17.jar Main
Error: Could not find or load main class Main
Caused by: java.lang.ClassNotFoundException: Main

A problémát az okozza, hogy az alapértelmezett osztály elérési útvonal tartalmazza az adott könyvtárat, amit a -cp paraméterrel teljesen felülírtunk. Így az adott könyvtárat is meg kell adni:

java -cp log4j-1.2.17.jar;. Main

Ez már jó, elindul, működik. Annyit még érdemes hozzátenni, hogy - miért is lenne egyszerű az élet? - Linux alatt kicsit másképp kell megadni, ott ugyanis az elválasztó karakter nem a pontosvessző (;), hanem a kettőspont (:). Linux alól tehát a fenti sort a következőképpen tudjuk futtatni:

java -cp log4j-1.2.17.jar:. Main

Apróságok ezek, de órákat, napokat el lehet tölteni azzal, hogy rájöjjünk, mi a probléma, ha nem értünk hozzá.

A futás eredménye egy egysoros bejegyzés a konzolon:

2019-09-30 08:53:25 INFO  Main:7 - Start of the main function.

Valamint létrejön egy logger-application.log nevű fájl az alábbi tartalommal:

2019-09-30 08:53:25 INFO  Main:7 - Start of the main function.
2019-09-30 08:53:25 DEBUG Main:8 - This is a debug message

Ha többször lefuttatjuk, akkor hozzáfűzi a naplófájlban a további bejegyzéseket, az elvárt módon.

Használhatóságban tehát igen éles a határ a csak standard könyvtárakat használó programok és a külső könyvtárakat is tartalmazó programok között. És ne feledjük: egy valós program tipikusan több tucat külső könyvtárat használ, melyek között függőségek lehetnek; akár több ezer forrásfájlt tartalmazhatnak, így áttekinthetetlenné bonyolódik a dolog. Erre is találtak ki megoldásokat, melyek kvázi-szabvánnyá nőtték ki magukat, melyek közül egyet bemutatok az alábbi alfejezetben.

A fenti példa Maven segítségével

Lássuk, hogyan lehet a fentieket valamelyest automatizálni! Erre számos módszert hoztak létre az idők folyamán, melyek közül néhányról szó van a fejlesztési eszközök oldalon is. Most a Java-ban legelterjedtebb Maven-t mutatom be. Töltsük le a szoftvert a https://maven.apache.org/ oldalról, csomagoljuk ki valahova, majd a bin könyvtárat adjuk hozzá a PATH környezeti változóhoz. Ellenőrizzük a működését a mvn -version paranccsal!

Első lépésben fel kell építenünk a Maven számára egy könyvtárszerkezetet!

  • src/: ide kerülnek a források.
    • main/: ide kerülnek a főprogram forrásai.
      • java/: ide kerülnek a Java források.
        • hu/faragocsaba/logging/: nem jó gyakorlat a gyökér csomagba helyezni a forrásokat, érdemes csomagszerkezetet kialakítani. Ha már egyébként is ki kell alakítanunk egy könyvtárszerkezetet, akkor ezen a ponton térünk át a javasolt gyakorlatra. A Java-ban a könyvtárszerkezetnek követnie kell a csomagszerkezetet. A csomaghierarchia elvileg bárhogy kinézhet, a valóságban viszont a gyártó weboldalának fordított címével kezdődik, majd a projekt nevével folytatódik, és ez tekinthető a projekt gyökerének. Tehát általánosságban a formátum com.mycompany.myproject. Ide helyezzük bele a fenti Main.java programot egyetlen módosítással: első sorként szúrjuk be a következőt: package hu.faragocsaba.logging;, majd a szokásos formázási gyakrolatnak megfelelően hagyjunk ki egy üres sort.
      • resources/: ide kerülnek a különböző erőforrás fájlok, pl. konfigurációs fájlok. Másoljuk ide a fenti log4j.properties fájlt!
    • test/: ide kerülnek az automatikus tesztek. Ebben a példában ez üresen marad, később ide is kerül tartalom.
      • java/: ide kerülnek az automatikus tesztek megvalósításai; most üresen marad.
      • resources/: teszt specifikus erőforrás osztályok. Pl. a fenti resources mutathat az éles környezetre, míg az itteni egy teszt környezetre. Ebben a példában üresen marad.
  • pom.xml: ez a Maven XML-formázott konfigurációs állománya, melyről részletesen lesz szó.

A pom.xml tartalma legyen az alábbi:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>hu.faragocsaba</groupId>
    <artifactId>logging</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>
</project>

A fájl felépítése:

  • A fejlécben megadtuk a névtereket és sémákat.
  • Ezt követően megadtuk az alapadatokat.
  • A tulajdonságok között beállítottuk a verziót. Ha ezt nem állítanánk be, akkor alapértelmezésben - kissé érthetetlen módon - az 1.5-öst választaná, amit viszont már nem támogat - no comment… És hogy ne legyen annyira egyszerű az élet: 1.10-ig kétféleképpen is megadhatjuk (1.x és x), a 11-estől az 1.11 már nem működik.
  • Itt jön a lényeg: megadtuk a függőséget.

Ebből a példából is látható egyébként, hogy recseg-ropog a Maven alatt a talaj: az XML önmagában túl bőbeszédű, egyre problémásabb, így várhatóan hamarosan a történelem szemétdobjára kerül, és helyét átveszi pl. a sokkal kompaktabb Gradle. Mindenesetre most még ezt fogjuk használni, és a továbbiakban csak a <dependency> részt fogom megadni, a többit vagy meg kell hagyni, vagy értelemszerűen módosítani (pl. artifactId).

Ha ezzel megvagyunk, adjuk ki a következő parancsot abból a könyvtárból, ahol a pom.xml található:

mvn clean install

Ez egyrészt törli a korábbi fordítás eredményeit (ami értelemszerűen az első futtatáskor még üres), másrészt végigviszi a teljes fordítási folyamatot. Először letölti a szükséges jar fájlokat. Ne ijedjünk meg, először sok mindent letölt, ugyanis magához a fordításhoz is szüksége van jar fájlokra, de ezt csak egyszer kell kivárni. Az ehhez a programhoz szükséges jar fájlt is letölti:

Downloading from central: https://repo.maven.apache.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.pom
Downloaded from central: https://repo.maven.apache.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.pom (22 kB at 87 kB/s)
Downloading from central: https://repo.maven.apache.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.jar
Downloaded from central: https://repo.maven.apache.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.jar (490 kB at 598 kB/s)

Az eredmény c:\Users\[username]\.m2\repository\ (ill. Linuxon a /home/[username]/.m2/repository/) könyvtárba kerül, a log4j-1.2.17.jar egészen pontosan ide: c:\Users\[username]\.m2\repository\log4j\log4j\1.2.17\log4j-1.2.17.jar. A fordítás eredménye a target/ könyvtárba kerül. Több minden kerül oda, számunkra most a legfontosabb a logging-1.0.jar.

A futtatás még eléggé macerás, ugyanis meg kell adnunk:

  • a keletkezett jar fájlt,
  • az összes felhasznált jar könyvtárat, valamint
  • a main() függvényt tartalmazó osztály teljes elérési útvonalát.

Tehát az indítása így néz ki:

java -cp target\logging-1.0.jar;c:\Users\[username]\.m2\repository\log4j\log4j\1.2.17\log4j-1.2.17.jar hu.faragocsaba.logging.Main

Futtatható jar készítése

Az indítás a fent megadott formában nem egyszerű! Mindig meg kell adni az összes könyvtár elérését, ami már egy közepes program esetén is áttekinthetetlen. A Maven-nek azonban vannak ún. beépülői, melynek segítéségével egyszerűsíthetünk a folyamaton. Ha a pom.xml tartalmát az alábbira változtatjuk, akkor egyrészt a keletkező jar fájlba beleteszi az összes szükséges osztályt, másrészt a fő függvényt tartalmazó osztály megadásával futtathatóvá tudjuk azt tenni:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>hu.faragocsaba</groupId>
    <artifactId>logging</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>hu.faragocsaba.logging.Main</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Így meg a pom.xml kezdi kinőni az áttekinthetőség korlátait, de sajnos nem alapértelmezett ez a teljesen logikus fordítás. Ha a fenti módon lefordítjuk (mvn clean install), akkor a target/ könyvtárban két jar keletkezik: a fenti logging-1.0.jar, valamint egy másik, jóval nagyobb méretű: logging-1.0-jar-with-dependencies.jar. Ezt már a következőképpen tudjuk indítani:

java -jar target\logging-1.0-jar-with-dependencies.jar

Természetesen át lehet nevezni, át lehet másolni, hogy még egyszerűbb legyen. Valamint Windows operációs rendszer alatt már attól elindul, ha rákattintunk, mintha futtatható lenne, pl. Total Commanderben Entert nyomunk.

Program elkészítése Eclipse segítéségével

A fentieket el lehet készíteni kézzel, akármilyen szövegszerkesztővel, majd parancssorból fordíthatjuk és futtathatjuk, de ez a folyamat túl sok időt vesz igénybe. Ha idáig nem tettük meg, ezen a ponton mindenképpen érdemes elkezdenünk használni valamilyen integrált fejlesztői környezetet (Integrated Development Environment, IDE). Most az egyik legelterjedtebb ilyen környezetet mutatom be: az Eclipse-t. Töltsük le a programot innen: https://www.eclipse.org/, és állítsuk be a Fejlesztőeszközök oldalon leírtak szerint. Hozzunk létre egy új programot úgy, ahogy az a Java bevezető oldalon látható (File → New → Other… → Maven → Maven Project stb.). Az alábbi lépéseket kell végrehajtanunk:

  • pom.xml szerkesztése: akár egy az egyben lecserélhetjük a tartalmat a fentire; egyébként is, elég furcsán formáz az Eclipse.
  • Jobb kattintás az src/main/java könyvtáron → New → Package, itt adjuk meg a telje csomagot, pl. hu.faragocsaba.logging. A háttérben elkészül a megfelelő könyvtárstruktúra.
  • Jobb kattintás a hu.faragocsaba.logging csomagon → New → Class → itt adjuk meg az osztály nevét (Main) → megadhatjuk, hogy generálja le a main() függvényt → Finish. Majd másoljuk be a fenti megvalósítást.
  • Jobb kattintás az src/main/resources könyvtáron → New → Other → General → File (hogy mért rejtették el ennyire a sima fájl létrehozását…) → Next → a fájl neve legyen log4j.properties → Finish. Majd másoljuk be a fájl tartalmát fentről.
  • A háttérben automatikusan lefordítja; sőt, le is tölti a szükséges jar fájlokat.
  • Jobb kattintás a main() függvényen → Run as → Java Application. Ha mindent jól csináltunk, a program lefut.
  • Jobb kattintás magán a projektnéven (logging) → Refresh (kb. középen van). Ennek következtében frissíti a fájlstruktúrát, és megjelenik a logger-application.log fájl. Az Eclipse-ben meg tudjuk nézni a tartalmát.
  • A következőkben elég a fenti ikonok között a zöld körben jibbra mutató fehér háromszögre kattintani az indításhoz; a fordítást az IDE elvégzi.

Egyéb naplózó keretrendszerek

A log4j-n kívül van még pár naplózó keretrendszer:

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License