Java inkorporerade ett loggnings-API-bibliotek som en del av sitt ramverk från JDK 1.4. Idag är detta ett inbyggt stöd från Java. Det här biblioteket är dock anpassningsbart och utbyggbart i den meningen att vi kan använda en eller flera alternativa loggningslösningar från tredje parts bibliotek. Även om dessa tredjepartslösningar har ett annat tillvägagångssätt för att skapa loggdata, delar de i slutändan samma mål att logga meddelanden från programkörning. Den här artikeln utforskar grunderna för loggning och visar hur det kan användas i ett Java-program.
Java-loggning
En logg innebär vanligtvis underhåll av någon sorts register. Ur programmeringsperspektiv är det en process att skriva meddelanden i en loggfil under programkörning. Fortsatta meddelandeloggar hänvisas, vanligtvis av programmeraren, för att samla in viss körtidsstatistisk information som, när den analyseras, kan avslöja oförutsedda situationer. Faktum är att det kan finnas många olika anledningar till varför loggning används och detta är bara en av dem. Enligt Java API-dokumentationen finns det fyra primära användningsområden för loggning:
- För problemdiagnos av slutanvändare och systemadministratörer.
- Det är bekvämt för fältserviceingenjörer att diagnostisera problemet från loggade meddelanden och åtgärda det snabbt.
- Utvecklingsorganisation kan spåra det interna utförandet av ett visst delsystem och analysera det.
- Utvecklare kan felsöka applikationen under utveckling genom att få en snabb inblick i det underliggande problemet från loggade meddelanden.
Java API-loggning är designad på ett billigt sätt i den meningen att den kan lämnas som en rest även i en produktionsapplikation. Detta skapar inte mycket omkostnader för effektiviteten av programexekveringen. API tillhandahåller mekanismen för att ändra produktionen av loggmeddelanden dynamiskt så att effekten av loggning kan minimeras under operationer som kräver maximal effektivitet. API:t består av ett antal klasser och gränssnitt som kan anpassas genom att utöka dem. Hela loggnings-API:et är paketerat under java.util.logging . Klasserna och gränssnitten i detta paket tillhandahåller kärnloggningsfaciliteterna i Java.
Loggningsnivåer
Brådskan med att logga in i ett Java-program kan kategoriseras i flera nivåer. Genom att nivellera upp och ner kan vi öka eller minska kostnaden för att logga i en produktionsapplikation. Så här kontrollerar vi effektiviteten av en applikations exekvering där det är nödvändigt att logga en eller flera av dess händelser. Detta uppnås genom en klass som heter Level , som definierar vikten av loggning. Loggnivån är ordnad och specificerad av statisk heltalskonstanter, såsom:
- Nivå.ALLA: Alla meddelanden loggas, oavsett betydelse
- Nivå.AV: Loggning är avstängd
- Level.SEVERE: Indikerar allvarligt fel; måste loggas
- Nivå.VARNING: Indikerar varningsmeddelanden
- Nivå.INFO: Runtime informationsmeddelande
- Level.CONFIG: Statiska konfigurationsmeddelanden
- Nivå.FIN: Spåra meddelanden
- Nivå.FINER: Detaljspårningsmeddelanden
- Level.FINEST: Mycket detaljerade spårningsmeddelanden
Loggningskomponenter
Vi behöver en logger instans för att göra någon form av inloggning i Java. Denna instans är ansvarig för att logga in data i en LogRecord . LogRecord instanser används för att skicka loggningsförfrågningar mellan loggningsramverk och individuella logghanterare. Java SE tillhandahåller fem typer av inbyggda hanterare:StreamHandler , ConsoleHandler , FileHandler , SocketHandler och MemoryHandler . Man kan dock skapa en ny hanterare eller utöka en av dessa som en anpassning. Hanterarna bestämmer vad de ska göra med loggposten; till exempel kan det finnas kvar i ett lokalt arkiv eller skicka det vidare till en server över ett nätverk. Java SE innehåller också två standardformaterare:SimpleFormatter och XMLFormatter . Dessa formaterare används för att formatera en LogRecord till mänskligt läsbart format respektive standard XML-format.
Det finns en LogManager klass som håller reda på global loggningsinformation, till exempel en hierarkisk namnrymd för namngivna loggare och en uppsättning loggningskontrollegenskaper från konfigurationsfilen. Det är centralt för inloggning i Java och styr i stort sett vad som ska loggas, var det ska loggas, inklusive andra initialiseringsdetaljer och så vidare.
Ett enkelt loggningsexempel
Skapa en logger objektet är mycket enkelt. Här är en mycket enkel kod för att illustrera det.
import java.util.logging.Logger;
public class App {
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) {
logger.info("This is a log message !!!");
logger.info("The name of the logger is " +
logger.getName() + " nwhich is same as class name: "
+ App.class.getName());
}
}
Loggare objekt brukar namnges med strängen värdet av ett hierarkiskt punktavgränsat namnområde. I föregående fall är det samma som klassnamnet. Namnet kan dock vara ett godtyckligt strängvärde, men normalt är namn baserade på paketnamnet eller klassnamnet för den loggade komponenten. Det är också möjligt att skapa en "anonym" logger som inte kommer att lagras i Logger namnutrymme.
Logga till en extern fil med XML-formatering
I följande kod omdirigeras loggmeddelandena till en fil med FileHandler .
| Obs! Filen kommer att skapas i projektkatalogen. |
FileHandler kan antingen skriva till en specificerad fil, eller så kan den skriva till en roterande uppsättning filer. Den roterande uppsättningen filer innebär att äldre filer namnges genom att lägga till 0,1,2 och så vidare i basfilnamnet. XMLFormatter är standardformateringen som används av FileHandler .
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
logger.addHandler(fileHandler);
logger.info("Log message redirected to a file");
logger.info("The name of the logger is " +
logger.getName() +
" nwhich is same as class name: "
+ App.class.getName());
}
}
Logga till en extern fil med anpassad formatering
Vi kommer att justera följande kod lite för att anpassa formateringen av meddelandet. Detta ändrar hur meddelandena skrivs i den externa filen.
| Obs! Observera loggfilens innehåll om hur formateringen har ändrats. |
import java.io.IOException;
import java.util.logging.*;
public class App {
private static FileHandler fileHandler;
private static Logger logger =
Logger.getLogger(App.class.getName());
public static void main(String[] args) throws
IOException {
fileHandler = new
FileHandler(App.class.getName() + ".log");
logger.setLevel(Level.ALL);
fileHandler.setFormatter(newCustomFormatter());
logger.addHandler(fileHandler);
logger.fine("Log message redirected to a file");
logger.finer("The name of the logger is " +
logger.getName());
loggerfinest("This is same as class name: " +
App.class.getName());
}
private static class CustomFormatter extends Formatter {
private static final String format =
"[%1$tF %1$tT] [%2$-4s] %3$s %n";
public String format(LogRecord record) {
returnString.format(format,
record.getMillis(),
record.getLevel().getLocalizedName(),
record.getMessage());
}
}
}
Det är allt. Experimentera med Java-loggning och prova många andra möjligheter. Se Java API-dokumenten där det behövs.
Andra loggningsramverk i Java
Ibland är det bekvämt att använda ett ramverk för loggning från tredje part, och det finns en hel del populära att välja mellan. Loggnings-API:et som tillhandahålls av SLF4J använder till exempel ett enkelt fasadmönster och är ett abstraktionslager som gör att applikationen kan kopplas bort från dess loggningsramverk. Log4j liknar syntaktisk inbyggd Java-loggning. Den har en standardkonfiguration för att mata ut alla loggmeddelanden till konsolen. Logback är en efterföljare till Log4j och är en förlängning av dess föregångare. tinyLog är ett lätt ramverk för loggning som kan användas med både Java och Android.
Slutsats
Loggningsprocessen är utformad för att vara enkel och effektiv för att leverera vad den ska göra. Det är möjligt att snabbt komma igång med Logging API:er i Java. Designen är utdragbar och kan anpassas efter utvecklarens slutbehov. Den här artikeln är en inblick i grunderna i Java-loggning. Många intrikata detaljer utelämnas för enkelhetens skull. Studera Java API-dokumentationen och andra lämpliga dokument för mer information om detta.
Referenser
- Översikt över Javaloggning
- Java API-dokumentation