Rozhranie API na protokolovanie platformy Java 9
1. Úvod
V tomto tutoriáli preskúmame novo zavedené rozhranie Logging API v prostredí Java 9 a implementujeme niekoľko príkladov, ktoré pokrývajú najbežnejšie prípady.
Toto API bolo zavedené v Jave pre poskytujú spoločný mechanizmus na spracovanie všetkých protokolov platformy a na vystavenie servisného rozhrania, ktoré je možné prispôsobiť knižnicami a aplikáciami. Týmto spôsobom môžu protokoly platformy JDK používať rovnaký rámec protokolovania ako aplikácia a je možné znížiť závislosti na projekte.
2. Vytvorenie vlastnej implementácie
V tejto časti si ukážeme hlavné triedy rozhrania Logging API, ktoré musíme implementovať, aby sme vytvorili nový protokolovač. Urobíme to tak, že implementujeme jednoduchý záznamník, ktorý vytlačí všetky protokoly do konzoly.
2.1. Vytvára sa Logger
Hlavná trieda, ktorú musíme vytvoriť, je Logger. Táto trieda musí implementovať System.Logger minimálne tieto štyri metódy:
- getName (): vráti meno záznamníka. Použije ju JDK na vytvorenie záznamníkov podľa názvu
- isLoggable (): označuje, pre ktoré úrovne je záznamník povolený
- denník (): je to metóda, ktorá tlačí protokol do ľubovoľného základného systému, ktorý aplikácia používa - v našom prípade konzoly. K dispozícii sú 2 denník () spôsoby implementácie, pričom každý z nich dostáva odlišné parametre
Pozrime sa, ako bude vyzerať naša implementácia:
public class ConsoleLogger implementuje System.Logger {@Override public String getName () {return "ConsoleLogger"; } @Override public boolean isLoggable (Level level) {return true; } @Override public void log (úroveň úrovne, balík ResourceBundle, správa reťazcov, vyhoditeľné) {System.out.printf ("ConsoleLogger [% s]:% s -% s% n", úroveň, správa, vyhodené); } @Override public void log (úroveň, balíček ResourceBundle, formát reťazca, objekt ... parametre) {System.out.printf ("ConsoleLogger [% s]:% s% n", úroveň, MessageFormat.format (formát, params)); }}Náš ConsoleLogger triedy má prednosť pred spomínanými štyrmi metódami. The getName () metóda vracia a Reťazec, kým isLoggable () metóda sa vracia pravda v každom prípade. Nakoniec tu máme 2 denník () metóda, ktorá výstup na konzolu.
2.2. Vytvára sa LoggerFinder
Len čo máme vytvorený záznamník, musíme implementovať a LoggerFinder ktorý vytvára naše príklady ConsoleLogger.
Aby sme to mohli urobiť, musíme rozšíriť abstraktnú triedu System.LoggerFinder a implementovať getLogger () metóda:
verejná trieda CustomLoggerFinder rozširuje System.LoggerFinder {@Override public System.Logger getLogger (názov reťazca, modul modulu) {return new ConsoleLogger (); }}V takom prípade vždy vraciame svoje ConsoleLogger.
Nakoniec musíme zaregistrovať naše LoggerFinder ako služba, aby ju mohla JDK odhaliť. Ak neposkytneme implementáciu, SimpleConsoleLogger sa použije predvolene.
Mechanizmus, ktorý JDK používa na načítanie implementácií, je ServiceLoader. Viac informácií o ňom nájdete v tomto výučbe.
Pretože používame Java 9, zbalíme našu triedu do modulu a zaregistrujeme našu službu v modul-info.java spis:
modul com.baeldung.logging {poskytuje java.lang.System.LoggerFinder s com.baeldung.logging.CustomLoggerFinder; export com.baeldung.logovanie; }Viac informácií o moduloch Java nájdete v tomto ďalšom návode.
2.3. Testujeme náš príklad
Aby sme si vyskúšali náš príklad, vytvorme ďalší modul, ktorý bude fungovať ako aplikácia. Toto bude obsahovať iba Hlavný triedy, ktorá využíva našu implementáciu služieb.
Táto trieda získa inštanciu našej ConsoleLogger zavolaním na System.getLogger () metóda:
verejná trieda MainApp {private static System.Logger LOGGER = System.getLogger ("MainApp"); public static void main (String [] args) {LOGGER.log (Level.ERROR, "test chyby"); LOGGER.log (Level.INFO, "informačný test"); }}Interne JDK prevezme naše CustomLoggerFinder implementáciu a vytvoriť inštanciu našej ConsoleLogger.
Potom vytvorme modul-info súbor pre tento modul:
modul com.baeldung.logging.app {}V tomto okamihu bude naša štruktúra projektu vyzerať takto:
├── src │ ├── moduly │ │ ├── com.baeldung.logovanie │ │ │ ├── com │ │ │ │ └── baeldung │ │ │ │ └── logovanie │ │ │ │ ├── ConsoleLogger .java │ │ │ │ └── CustomLoggerFinder.java │ │ │ └── modul-info.java │ │ ├── com.baeldung.logging.app │ │ │ ├── com │ │ │ │ └── baeldung │ │ │ │ └── logovanie │ │ │ │ └── aplikácia │ │ │ │ └── MainApp.java │ │ │ └── modul-info.java └──Nakoniec ideme kompilovať naše dva moduly a umiestnime ich do a mody adresár:
javac --module-path mods -d mods / com.baeldung.logging \ src / modules / com.baeldung.logging / module-info.java \ src / modules / com.baeldung.logging / com / baeldung / loging / * .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/*.javaNakoniec spustíme Hlavný trieda aplikácia modul:
java --module-path mods \ -m com.baeldung.logging.app/com.baeldung.logging.app.MainAppAk sa pozrieme na výstup z konzoly, môžeme vidieť, že naše protokoly sú tlačené pomocou nášho ConsoleLogger:
ConsoleLogger [ERROR]: chybový test ConsoleLogger [INFO]: informačný test3. Pridanie externého rámca protokolovania
V našom predchádzajúcom príklade sme zaznamenávali všetky naše správy do konzoly, čo je to isté, čo predvolený záznamník. Jedným z najužitočnejších použití rozhrania Logging API v prostredí Java 9 je nechať aplikácie smerovať protokoly JDK do rovnakého rámca protokolovania, aký používa aplikácia., a to budeme v tejto časti robiť.
Vytvoríme nový modul, ktorý používa SLF4J ako protokolovaciu fasádu a Logback ako protokolovací rámec.
Pretože sme už vysvetlili základné informácie v predchádzajúcej časti, teraz sa môžeme zamerať na to, ako pridať externý rámec protokolovania.
3.1. Vlastné implementácie pomocou SLF4J
Najskôr implementujeme ďalší Logger ktorý vytvorí nový záznamník SLF4J pre každú inštanciu:
verejná trieda Slf4jLogger implementuje System.Logger {súkromné konečné meno reťazca; súkromný konečný logger; public Slf4jLogger (názov reťazca) {this.name = meno; logger = LoggerFactory.getLogger (meno); } @Override public String getName () {návratové meno; } // ...}Všimnite si, že toto Logger je org.slf4j.Logger.
Pre ostatné metódy budeme sa spoliehať na implementáciu v inštancii záznamníka SLF4J. Preto náš Logger bude povolené, ak je zapnutý záznamník SLF4J:
@Override public boolean isLoggable (Level level) {switch (level) {case OFF: return false; prípad TRACE: návrat logger.isTraceEnabled (); prípad DEBUG: return logger.isDebugEnabled (); prípad INFO: return logger.isInfoEnabled (); prípad UPOZORNENIE: return logger.isWarnEnabled (); case ERROR: return logger.isErrorEnabled (); prípad VŠETKY: predvolené: návrat true; }}Metódy protokolu budú volať príslušnú metódu protokolu SLF4J v závislosti od použitej úrovne protokolu:
@Override public void log (úroveň úrovne, balík ResourceBundle, správa reťazcov, hodená hodená) {if (! IsLoggable (úroveň)) {návrat; } switch (level) {case TRACE: logger.trace (msg, thrown); prestávka; DEBUG prípadu: logger.debug (správa, vyhodené); prestávka; prípad INFO: logger.info (správa, vyhodené); prestávka; prípad UPOZORNENIE: logger.warn (správa, vyhodené); prestávka; case ERROR: logger.error (msg, thrown); prestávka; prípad VŠETKO: predvolené: logger.info (správa, vyhodené); }} @Override public void log (úroveň úrovne, balík ResourceBundle, formát reťazca, objekt ... parametre) {if (! IsLoggable (level)) {return; } String message = MessageFormat.format (format, params); switch (level) {case TRACE: logger.trace (message); prestávka; // ... // rovnaké ako predchádzajúci prepínač}}Nakoniec vytvoríme nový LoggerFinder ktorý používa naše Slf4jLogger:
verejná trieda Slf4jLoggerFinder rozširuje System.LoggerFinder {@Override public System.Logger getLogger (názov reťazca, modul modulu) {vrátiť nový Slf4jLogger (názov); }}3.2. Konfigurácia modulu
Keď máme všetky naše triedy implementované, zaregistrujme našu službu v našom module a pridajme závislosť modulu SLF4J:
modul com.baeldung.logging.slf4j {vyžaduje org.slf4j; poskytuje java.lang.System.LoggerFinder com.baeldung.logging.slf4j.Slf4jLoggerFinder; export com.baeldung.logging.slf4j; }Tento modul bude mať nasledujúcu štruktúru:
├── src │ ├── moduly │ │ ├── com.baeldung.logging.slf4j │ │ │ ├── com │ │ │ │ └── baeldung │ │ │ │ └── logovanie │ │ │ │ └─ ─ slf4j │ │ │ │ ├── Slf4jLoggerFinder.java │ │ │ │ └── Slf4jLogger.java │ │ │ └── modul-info.java └──Teraz môžeme tento modul skompilovať do mody adresára, ako sme to urobili v predchádzajúcej časti.
Všimnite si, že na zostavenie tohto modulu musíme umiestniť slf4j-api jar do adresára mods. Nezabudnite tiež použiť modulárnu verziu knižnice. Najnovšiu verziu nájdete v Maven Central.
3.3. Pridáva sa prihlásenie
Sme takmer hotoví, ale stále musíme pridať závislosti a konfiguráciu Logback. Urobíte to tak, že logback-classic a logback-core poháre v mody adresár.
Rovnako ako predtým sa musíme uistiť, že používame modulárnu verziu knižnice. Najnovšiu verziu opäť nájdete v Maven Central.
Nakoniec vytvoríme konfiguračný súbor Logback a umiestnime ho do nášho mody adresár:
% d {rrrr-MM-dd HH: mm: ss} [% thread]% -5level% logger {36} -% msg% n 3.4. Spúšťame našu aplikáciu
V tomto okamihu môžeme spustiť našu aplikácia pomocou nášho modulu SLF4J.
V tomto prípade, tiež musíme určiť náš konfiguračný súbor Logback:
java --module-path mods \ -Dlogback.configurationFile = mods / logback.xml \ -m com.baeldung.logging.app/com.baeldung.logging.app.MainAppNakoniec, ak skontrolujeme výstup, môžeme vidieť, že naše protokoly sa tlačia pomocou našej konfigurácie Logback:
2018-08-25 14:02:40 [main] CHYBA MainApp - test chyby 2018-08-25 14:02:40 [main] INFO MainApp - informačný test4. Záver
V tomto článku sme si ukázali, ako vytvoriť vlastný záznamník v prostredí Java 9 pomocou nového API na protokolovanie platformy. Implementovali sme príklad pomocou externého protokolovacieho rámca, ktorý je jedným z najužitočnejších prípadov použitia tohto nového API.
Celý zdrojový kód príkladov je ako vždy k dispozícii na serveri GitHub.
