Lær det grundlæggende i Java-logging

Java inkorporerede et lognings-API-bibliotek som en del af sin ramme fra JDK 1.4. I dag er dette en indbygget understøttelse fra Java. Dette bibliotek kan dog tilpasses og udvides i den forstand, at vi kan bruge en eller flere alternative logningsløsninger leveret af tredjepartsbiblioteker. Selvom disse tredjepartsløsninger har en anden tilgang til at oprette logdata, deler de i sidste ende det samme mål om at logge beskeder fra applikationens runtime. Denne artikel udforsker det grundlæggende i logning og viser, hvordan det kan bruges i et Java-program.

Java-logning

En log betyder normalt vedligeholdelse af en form for registrering. Fra et programmeringsperspektiv er det en proces med at skrive beskeder i en logfil under programafvikling. Vedvarende beskedlogfiler henvises, typisk af programmøren, for at indsamle visse statistiske oplysninger om runtime, der, når de analyseres, kan afsløre uforudsete situationer. Faktisk kan der være adskillige forskellige årsager til, at logning bruges, og dette er kun en af ​​dem. Ifølge Java API-dokumentationen er der fire primære anvendelser af logning:

• Til problemdiagnose af slutbrugere og systemadministratorer.
• Det er praktisk for feltserviceteknikere at diagnosticere problemet ud fra loggede meddelelser og rette det hurtigt.
• Udviklingsorganisation kan spore den interne udførelse af et bestemt delsystem og analysere det.
• Udviklere kan fejlsøge applikationen under udvikling ved at få et hurtigt indblik i det underliggende problem fra loggede meddelelser.

Java API-logning er designet på en billig måde i den forstand, at den kan efterlades som en rest selv i en produktionsapplikation. Dette skaber ikke meget overhead til effektiviteten af ​​programudførelsen. API'en giver mekanismen til at ændre produktionen af ​​logmeddelelser dynamisk, så virkningen af ​​logning kan minimeres under operationer, der kræver maksimal effektivitet. API'et består af en række klasser og grænseflader, der kan tilpasses ved at udvide dem. Hele lognings-API'en er pakket under java.util.logging . Klasserne og grænsefladerne i denne pakke giver de centrale logningsfaciliteter i Java.

Logningsniveauer

Det haster med at logge på et Java-program kan kategoriseres i flere niveauer. Ved at nivellere op og ned kan vi øge eller mindske omkostningerne ved at logge i en produktionsapplikation. Sådan styrer vi effektiviteten af ​​en applikations eksekvering, hvor det er nødvendigt at logge en eller flere af dens hændelser. Dette opnås gennem en klasse kaldet Niveau , som definerer vigtigheden af ​​logning. Logniveauet er ordnet og specificeret af statisk heltalskonstanter, såsom:

• Niveau.ALLE: Alle beskeder logges, uanset vigtighed
• Niveau.FRA: Logning er slået fra
• Niveau.SVERE: Indikerer alvorlig fejl; skal logges
• Niveau.ADVARSEL: Indikerer advarselsmeddelelser
• Niveau.INFO: Runtime informationsmeddelelse
• Niveau.CONFIG: Statiske konfigurationsmeddelelser
• Niveau.FIN: Sporing af beskeder
• Niveau.FINER: Detaljesporingsmeddelelser
• Niveau.FINEST: Meget detaljerede sporingsmeddelelser

Logføringskomponenter

Vi har brug for en Logger forekomst til at udføre nogen form for logning i Java. Denne instans er ansvarlig for at logge data ind i en LogRecord . LogRecord instanser bruges til at sende logningsanmodninger mellem logningsrammer og individuelle logbehandlere. Java SE giver fem typer indbyggede handlere:StreamHandler , ConsoleHandler , FileHandler , SocketHandler og MemoryHandler . Man kan dog oprette en ny handler eller udvide en af ​​disse som en tilpasning. Behandlerne bestemmer, hvad de skal gøre med logposten; for eksempel kan det bevares i et lokalt lager eller videregive det til en server over et netværk. Java SE indeholder også to standardformatere:SimpleFormatter og XMLFormatter . Disse formatere bruges til at formatere en LogRecord i henholdsvis menneskeligt læsbart format og standard XML-format.

Der er en LogManager klasse, som holder styr på globale logningsoplysninger, såsom et hierarkisk navneområde for navngivne Loggere og et sæt logningskontrolegenskaber fra konfigurationsfilen. Det er centralt for at logge på Java og styrer stort set, hvad der skal logges, hvor der skal logges, inklusive andre initialiseringsdetaljer og så videre.

Et simpelt eksempel på logning

Oprettelse af en logger objektet er meget enkelt. Her er en meget enkel kode til at illustrere 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());
   }
}

Logger objekter navngives normalt ved hjælp af strengen værdien af ​​et hierarkisk punktsepareret navneområde. I det foregående tilfælde er det det samme som klassenavnet. Navnet kan dog være en vilkårlig strengværdi, men normalt er navne baseret på pakkenavnet eller klassenavnet på den loggede komponent. Det er også muligt at oprette en "anonym" logger, som ikke vil blive gemt i Loggeren navneområde.

Log til en ekstern fil ved hjælp af XML-formatering

I den følgende kode omdirigeres logmeddelelserne til en fil ved hjælp af FileHandler .

FileHandler kan enten skrive til en specificeret fil, eller den kan skrive til et roterende sæt filer. Det roterende sæt filer betyder, at ældre filer navngives ved at tilføje 0,1,2 og så videre i basisfilnavnet. XMLFormatter er standardformateringen brugt af 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());
   }
}

Logge til en ekstern fil ved hjælp af brugerdefineret formatering

Vi justerer den følgende kode lidt for at tilpasse formateringen af ​​beskeden. Dette ændrer, hvordan meddelelserne skrives i den eksterne fil.

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 er alt. Eksperimenter med Java-logning og prøv mange andre muligheder. Se Java API-dokumenterne, hvor det er nødvendigt.

Andre logningsrammer i Java

Nogle gange er det praktisk at bruge en tredjeparts logningsramme, og der er en del populære at vælge imellem. For eksempel bruger log-API'en leveret af SLF4J et simpelt facademønster, et abstraktionslag, der gør det muligt at afkoble applikationen fra dens logningsramme. Log4j ligner syntaktisk indbygget Java-logning. Den har en standardkonfiguration til at udsende alle logmeddelelser til konsollen. Logback er en efterfølger af Log4j og er en forlængelse af dens forgænger. tinyLog er en let logningsramme, der kan bruges med både Java og Android.

Konklusion

Logningsprocessen er designet til at være enkel og effektiv til at levere det, den skal gøre. Det er muligt hurtigt at komme i gang med Logging API'er i Java. Designet kan udvides og kan tilpasses efter udviklerens slutbehov. Denne artikel er et indblik i det grundlæggende i Java-logning. Mange indviklede detaljer er udeladt for nemheds skyld. Studer Java API-dokumentationen og andre relevante dokumenter for at få flere detaljer om dette.

Referencer

• Java-logføringsoversigt
• Java API-dokumentation