Java 9 Platform Logging API

1. Bemutatkozás

Ebben az oktatóanyagban feltárjuk az újonnan bevezetett Naplózás API-t a Java 9-ben, és néhány példát bemutatunk a leggyakoribb esetekre.

Ezt az API-t a Java-ban vezették be közös mechanizmust biztosítson az összes platformnapló kezelésére, valamint a könyvtárak és alkalmazások által testreszabható szolgáltatási felület feltárására. Így a JDK platformnaplók ugyanazt a naplózási keretet használhatják, mint az alkalmazás, és csökkenthetők a projektfüggőségek.

2. Egyéni megvalósítás létrehozása

Ebben a részben bemutatjuk a Naplózási API főbb osztályait, amelyeket végre kell hajtanunk egy új naplózó létrehozásához. Ezt egy egyszerű naplózó végrehajtásával tesszük meg, amely kinyomtatja az összes naplót a konzolra.

2.1. A Logger

A fő osztály, amelyet létre kell hoznunk, a Logger. Ennek az osztálynak kell megvalósítania a System.Logger interfész és legalább ez a négy módszer:

  • getName (): a naplózó nevét adja vissza. A JDK arra fogja használni, hogy név szerint naplózókat hozzon létre
  • isLoggable (): jelzi, hogy a naplózó milyen szintekre van engedélyezve
  • napló (): ez a módszer nyomtatja ki a naplót az alkalmazás által használt alaprendszerre - esetünkben a konzolra. 2 van napló () módszerek, amelyek mindegyike különböző paramétereket kap

Lássuk, hogyan fog kinézni a megvalósításunk:

public class ConsoleLogger implementálja a System.Logger {@Orride public String getName () {return "ConsoleLogger"; } @Orride public boolean isLoggable (Level level) {return true; } @Orride public void log (Level level, ResourceBundle bundle, String msg, Throwable dobott) {System.out.printf ("ConsoleLogger [% s]:% s -% s% n", level, msg, dobott); } @Orride public void log (Level level, ResourceBundle bundle, String format, Object ... params) {System.out.printf ("ConsoleLogger [% s]:% s% n", level, MessageFormat.format (format, params)); }}

A mi ConsoleLogger osztály felülírja az említett négy módszert. A getName () metódus a Húr, amíg a isLoggable () metódus visszatér igaz minden esetben. Végül megvan a 2 napló () metódus, amelyet a konzolnak ad ki.

2.2. A LoggerFinder

Miután létrehoztuk a naplózónkat, végre kell hajtanunk a LoggerFinder ami példáinkat hozza létre ConsoleLogger.

Ehhez ki kell terjesztenünk az absztrakt osztályt System.LoggerFinder és végrehajtja a getLogger () módszer:

public class CustomLoggerFinder kiterjeszti a System.LoggerFinder {@Orride public System.Logger getLogger (karakterlánc neve, modul modul) {return new ConsoleLogger (); }}

Ebben az esetben mindig visszaküldjük a sajátunkat ConsoleLogger.

Végül regisztrálnunk kell LoggerFinder szolgáltatásként, így a JDK felfedezheti. Ha nem nyújtunk megvalósítást, akkor a SimpleConsoleLogger alapértelmezés szerint lesz használva.

A JDK által a megvalósítások betöltésére használt mechanizmus a ServiceLoader. További információt erről az oktatóanyagról talál.

Mivel Java 9-et használunk, osztályunkat csomagoljuk egy modulba, és regisztráljuk szolgáltatásunkat a module-info.java fájl:

modul com.baeldung.logging {biztosítja a java.lang.System.LoggerFinder fájlt a com.baeldung.logging.CustomLoggerFinder programmal; export com.baeldung.logging; }

A Java modulokkal kapcsolatos további információkért tekintse meg ezt a másik oktatóanyagot.

2.3. Példánk tesztelése

Példánk teszteléséhez hozzunk létre egy másik modult, amely alkalmazásként fog működni. Ez csak a osztály, amely a szolgáltatás megvalósítását használja.

Ez az osztály megkapja a mi példányunkat ConsoleLogger felhívásával a System.getLogger () módszer:

public class MainApp {privát statikus System.Logger LOGGER = System.getLogger ("MainApp"); public static void main (String [] args) {LOGGER.log (Level.ERROR, "hibateszt"); LOGGER.log (Level.INFO, "infóteszt"); }}

Belsőleg a JDK felveszi a mi ügyünket CustomLoggerFinder megvalósítása és hozzon létre egy példányt a ConsoleLogger.

Ezt követően hozzuk létre a module-info fájl ehhez a modulhoz:

com.baeldung.logging.app {} modul

Ezen a ponton a projekt felépítése a következőképpen fog kinézni:

├── src │ ├── modulok │ │ ├── com.baeldung.logging │ │ │ ├── com │ │ │ │ └── baeldung │ │ │ │ └── naplózás │ │ │ │ ├── ConsoleLogger .java │ │ │ │ └── CustomLoggerFinder.java │ │ │ └── module-info.java │ │ ├── com.baeldung.logging.app │ │ │ ├── com │ │ │ │ └── baeldung Ging │ │ │ └── naplózás │ │ │ │ └── app │ │ │ │ └── MainApp.java │ │ │ └── module-info.java └──

Végül összeállítjuk a két modulunkat, és elhelyezzük őket a módok Könyvtár:

javac - modul-path mods -d mods / com.baeldung.logging \ src / modules / com.baeldung.logging / module-info.java \ src / modules / com.baeldung.logging / com / baeldung / logging / * .java javac --module-path mods -d mods / com.baeldung.logging.app \ src / modules / com.baeldung.logging.app / module-info.java \ src / modules / com.baeldung.logging.app /com/baeldung/logging/app/*.java

Végül futtassuk a osztálya kb modul:

java --module-path mods \ -m com.baeldung.logging.app/com.baeldung.logging.app.MainApp

Ha megnézzük a konzol kimenetét, láthatjuk, hogy a naplóinkat a mi segítségével nyomtatjuk ki ConsoleLogger:

ConsoleLogger [ERROR]: hibateszt ConsoleLogger [INFO]: információs teszt

3. Külső naplózási keretrendszer hozzáadása

Előző példánkban az összes üzenetünket a konzolba naplóztuk, ami megegyezik az alapértelmezett naplózóval. A Naplózás API egyik leghasznosabb felhasználása a Java 9-ben az, hogy hagyja, hogy az alkalmazások átirányítsák a JDK-naplókat ugyanazon naplózási keretrendszerhez, amelyet az alkalmazás, és ezt fogjuk tenni ebben a szakaszban.

Létrehozunk egy új modult, amely az SLF4J-t használja naplózási homlokzatként, a Logback pedig naplózási keretként.

Mivel az előző szakaszban már elmagyaráztuk az alapokat, most arra összpontosíthatunk, hogyan adjunk hozzá egy külső naplózási keretet.

3.1. Egyedi megvalósítások az SLF4J használatával

Először megvalósítunk egy másikat Logger amely létrehoz egy új SLF4J naplózót minden példányhoz:

public class Slf4jLogger implementálja a System.Logger {private final String name; saját végső naplózó naplózó; public Slf4jLogger (karakterlánc neve) {this.name = név; logger = LoggerFactory.getLogger (név); } @Orride public String getName () {return name; } // ...}

Vedd észre, hogy ez Logger egy org.slf4j.Logger.

A többi módszer esetében támaszkodni fogunk az SLF4J naplózó példány megvalósítására. Ezért a mi Logger engedélyezve lesz, ha az SLF4J naplózó engedélyezve van:

@Orride public boolean isLoggable (Level level) {switch (level) {case OFF: return false; case TRACE: return logger.isTraceEnabled (); eset DEBUG: return logger.isDebugEnabled (); eset INFO: return logger.isInfoEnabled (); eset FIGYELEM: return logger.isWarnEnabled (); case ERROR: return logger.isErrorEnabled (); case ALL: alapértelmezett: return true; }}

És a naplózási módszerek meghívják a megfelelő SLF4J naplózó metódust az alkalmazott naplószinttől függően:

@Orride public void log (Level level, ResourceBundle bundle, String msg, Throwable dobott) {if (! IsLoggable (level)) {return; } kapcsoló (szint) {eset TRACE: logger.trace (msg, dobott); szünet; eset DEBUG: logger.debug (msg, dobott); szünet; eset INFO: logger.info (msg, dobva); szünet; eset FIGYELEM: logger.warn (msg, dobva); szünet; eset ERROR: logger.error (msg, dobott); szünet; ALL eset: alapértelmezett: logger.info (msg, dobott); }} @Orride public void log (Level level, ResourceBundle bundle, String format, Object ... params) {if (! IsLoggable (level)) {return; } String üzenet = MessageFormat.format (formátum, paraméterek); kapcsoló (szint) {case TRACE: logger.trace (üzenet); szünet; // ... // ugyanaz, mint az előző kapcsolónál}}

Végül hozzunk létre egy újat LoggerFinder hogy használja a mi Slf4jLogger:

public class Slf4jLoggerFinder kiterjeszti a System.LoggerFinder {@Orride public System.Logger getLogger (String name, Module module) {return new Slf4jLogger (name); }}

3.2. Modul konfigurálása

Miután az összes osztályunkat megvalósítottuk, regisztráljuk szolgáltatásunkat a modulunkban, és adjuk hozzá az SLF4J modul függőségét:

modul com.baeldung.logging.slf4j {org.slf4j szükséges; biztosítja a java.lang.System.LoggerFinder alkalmazást a com.baeldung.logging.slf4j.Slf4jLoggerFinder programmal; exportálja a com.baeldung.logging.slf4j; }

Ennek a modulnak a következő szerkezete lesz:

├── src │ ├── modulok │ │ ├── com.baeldung.logging.slf4j │ │ │ ├── com │ │ │ │ └── baeldung │ │ │ │ └── naplózás │ │ │ │ └ ─ slf4j │ │ │ │ ├── Slf4jLoggerFinder.java │ │ │ │ └── Slf4jLogger.java │ │ │ └── module-info.java └──

Most lefordíthatjuk ezt a modult a módok könyvtárat, ahogy az előző szakaszban tettük.

Figyeljük meg, hogy a modul fordításához az slf4j-api jar-ot a mod könyvtárba kell helyezni. Ne felejtse el használni a könyvtár modulizált változatát sem. A legújabb verzió a Maven Central oldalon található.

3.3. Logback hozzáadása

Már majdnem készen vagyunk, de még hozzá kell adnunk a Logback függőségeket és konfigurációt. Ehhez tegye a logback-klasszikus és logback-core üvegek a módok Könyvtár.

A korábbiakhoz hasonlóan meg kell bizonyosodnunk arról, hogy a könyvtár modulált változatát használjuk. Ismét a legújabb verzió megtalálható a Maven Central-ban.

Végül hozzunk létre egy Logback konfigurációs fájlt, és helyezzük el a fájlunkban módok Könyvtár:

    % d {éééé-hh-nn óó: pp: ss} [% thread]% -5level% logger {36} -% msg% n 

3.4. Alkalmazásunk futtatása

Ezen a ponton futhatunk kb az SLF4J modulunk használatával.

Ebben az esetben, meg kell adnunk a Logback konfigurációs fájlunkat is:

java --module-path mods \ -Dlogback.configurationFile = mods / logback.xml \ -m com.baeldung.logging.app/com.baeldung.logging.app.MainApp

Végül, ha ellenőrizzük a kimenetet, láthatjuk, hogy a naplóink ​​a Logback konfigurációnk segítségével vannak kinyomtatva:

2018-08-25 14:02:40 [main] HIBA MainApp - hibateszt 2018-08-25 14:02:40 [main] INFO MainApp - infóteszt

4. Következtetés

Ebben a cikkben bemutattuk, hogyan hozhat létre egyéni naplózót a Java 9-ben az új Platform Naplózás API használatával. Ezenkívül megvalósítottunk egy példát egy külső naplózási keretrendszer használatával, amely az új API egyik leghasznosabb felhasználási esete.

Mint mindig, a példák teljes forráskódja elérhető a GitHubon.