I den här handledningen lär vi oss om Java Logging och dess olika komponenter med hjälp av exempel.
Java tillåter oss att skapa och fånga loggmeddelanden och filer genom loggningsprocessen.
I Java kräver loggning ramar och API: er. Java har en inbyggd loggningsram i java.util.loggingpaketet.
Vi kan också använda tredjepartsramar som Log4j, Logback och många fler för loggningsändamål.
Java-loggningskomponenter
Figuren nedan representerar kärnkomponenterna och kontrollflödet för Java Logging API ( java.util.logging).
Java-loggning
1. Logger
Den Loggerklass tillhandahåller metoder för loggning. Vi kan starta objekt från Loggerklassen och anropa dess metoder för loggningsändamål.
Låt oss ta ett exempel.
Logger logger = Logger.getLogger("newLoggerName");
Den getLogger()metod för Loggerklassen används för att hitta eller skapa en ny Logger. Strängargumentet definierar loggerns namn.
Här skapar detta ett nytt Loggerobjekt eller returnerar ett befintligt Loggermed samma namn.
Det är en konvention att definiera en Loggerefter den nuvarande klassen med class.getName().
Logger logger = Logger.getLogger(MyClass.class.getName());
Obs! Den här metoden kastas NullPointerExceptionom det passerade namnet är null.
Var och en Loggerhar en nivå som avgör vikten av loggmeddelandet. Det finns 7 grundläggande loggnivåer:
| Loggnivå (i fallande ordning) | Använda sig av |
|---|---|
| SVÅR | allvarligt misslyckande |
| VARNING | varningsmeddelande, ett potentiellt problem |
| INFO | allmän körtidsinformation |
| KONFIG | konfigurationsinformation |
| BRA | allmän utvecklarinformation (spåra meddelanden) |
| FINER | detaljerad utvecklarinformation (spåra meddelanden) |
| FINASTE | mycket detaljerad utvecklarinformation (spåra meddelanden) |
| AV | stäng av loggning för alla nivåer (fånga ingenting) |
| ALLT | aktivera loggning för alla nivåer (fånga allt) |
Varje loggnivå har ett heltal som bestämmer deras svårighetsgrad förutom två specialloggnivåer OFFoch ALL.
Loggar meddelandet
Som standard loggas alltid de tre bästa loggnivåerna. För att ställa in en annan nivå kan vi använda följande kod:
logger.setLevel(Level.LogLevel); // example logger.setLevel(Level.FINE);
I det här exemplet är endast nivå FINEoch nivåer ovan inställda att loggas. Alla andra loggmeddelanden tas bort.
Nu för att logga ett meddelande använder vi log()metoden.
logger.log(Level.LogLevel, "log message"); // example logger.log(Level.INFO, "This is INFO log level message");
Det finns stenografiska metoder för loggning på önskade nivåer.
logger.info( "This is INFO log level message"); logger.warning( "This is WARNING log level message");
Alla loggförfrågningar som har passerat den inställda loggnivån vidarebefordras sedan till LogRecord .
Obs: Om en loggers nivå är inställd nullärvs den från dess förälder och så vidare upp i trädet.
2. Filter
Ett filter (om det finns) avgör om LogRecord ska vidarebefordras eller inte. Som namnet antyder filtrerar det loggmeddelandena enligt specifika kriterier.
Ett LogRecord skickas endast från loggaren till logghanteraren och från logghanteraren till externa system om den uppfyller de angivna kriterierna.
// set a filter logger.setFilter(filter); // get a filter Filter filter = logger.getFilter();
3. Handlers (Appenders)
Logghanteraren eller appenders tar emot LogRecord och exporterar den till olika mål.
Java SE erbjuder 5 inbyggda hanterare:
| Hanterare | Använda sig av |
|---|---|
StreamHandler | skriver till en OutputStream |
ConsoleHandler | skriver till konsolen |
FileHandler | skriver till filen |
SocketHandler | skriver till fjärr TCP-portar |
MemoryHandler | skriver till minnet |
En hanterare kan skicka LogRecord till ett filter för att avgöra om det kan vidarebefordras till externa system eller inte.
För att lägga till en ny hanterare använder vi följande kod:
logger.addHandler(handler); // example Handler handler = new ConsoleHandler(); logger.addHandler(handler);
För att ta bort en hanterare använder vi följande kod:
logger.removeHandler(handler); // example Handler handler = new ConsoleHandler(); logger.addHandler(handler); logger.removeHandler(handler);
En logger kan ha flera hanterare. För att få alla hanterare använder vi följande kod:
Handler() handlers = logger.getHandlers();
4. Formaterare
En hanterare kan också använda en formaterare för att formatera LogRecord- objektet till en sträng innan den exporteras till externa system.
Java SE har två inbyggda formaterare :
| Formaterare | Använda sig av |
|---|---|
SimpleFormatter | formaterar LogRecord till sträng |
XMLFormatter | formaterar LogRecord till XML-form |
Vi kan använda följande kod för att formatera en hanterare:
// formats to string form handler.setFormatter(new SimpleFormatter()); // formats to XML form handler.setFormatter(new XMLFormatter());
LogManager
Den LogManager objekt håller reda på den globala loggningsinformationen. Det läser och underhåller loggkonfigurationen och loggerinstanserna.
Logghanteraren är en singleton, vilket innebär att endast en instans av den instansieras.
För att få logghanterarinstansen använder vi följande kod:
LogManager manager = new LogManager();
Fördelar med loggning
Här är några av fördelarna med att logga in i Java.
- hjälper till att övervaka flödet av programmet
- hjälper till att fånga upp eventuella fel
- ger stöd för problemdiagnos och felsökning
