1.1 Inleiding tot logboeken
Het logboek is een lijst met gebeurtenissen die hebben plaatsgevonden. Bijna als een nautisch dagboek of dagboek. Welnu, een logger is dus een object waarmee u kunt loggen. Bij het programmeren is het gebruikelijk om bijna alles te loggen. En op Java is alles zo en zelfs een beetje meer.
Feit is dat Java-programma's heel vaak grote servertoepassingen zijn zonder gebruikersinterface, console, enzovoort. Ze verwerken verzoeken van duizenden gebruikers tegelijkertijd en vaak treden er verschillende fouten op. Vooral wanneer verschillende threads met elkaar beginnen te interfereren.
En in feite is de enige manier om zelden gereproduceerde fouten en mislukkingen in een dergelijke situatie te vinden, door alles wat er in elke thread gebeurt naar het log / bestand te schrijven.
Meestal wordt er informatie naar het logboek geschreven over de parameters van de methode waarmee het is aangeroepen, alle onderschepte fouten en veel tussentijdse informatie. Hoe vollediger het logboek, hoe gemakkelijker het is om de volgorde van gebeurtenissen te herstellen en de oorzaken van een storing of fout op te sporen.
Maar hoe groter het blok, hoe moeilijker het is om ermee te werken. Soms bereiken de logs meerdere gigabytes per dag. Dit is goed.
1.2 Mislukte logboeken
Als eerste logs gebruikten de ontwikkelaars gewoon output naar de console . Het is handig om dit te doen tijdens het debuggen van applicaties - wanneer alle belangrijke informatie en variabele waarden naar de console worden geschreven. Maar zo'n logboek is volledig niet van toepassing tijdens de normale werking van de applicatie.
Ten eerste wil de applicatie misschien iets naar de console zelf sturen en wil de gebruiker de service-informatie die bedoeld is voor de programmeur helemaal niet zien.
Ten tweede is de grootte van de consolebuffer beperkt, je kunt daar niet veel schrijven.
En tot slot, ten derde, informatie over programmafouten die over een lange periode is verzameld, moet naar de programmaontwikkelaars worden gestuurd. En het handigst is om al deze informatie in één keer naar een bestand te schrijven.
De ontwikkelaars losten snel het eerste probleem op - ze kwamen met een andere uitvoerstroom - System.err. Je kunt er berichten naar schrijven en ze worden naar een aparte thread gestuurd, en niet naar de standaardconsole.
En zelfs het probleem met het schrijven naar een bestand was opgelost:
// Define the file to which we will write the log
System.setErr(new PrintStream(new File("log.txt")));
// Display messages
System.err.println("Message 1");
System.err.println("Message 2");
// Display an error message
try {
throw new Exception("Error message");
} catch (Exception e) {
e.printStackTrace();
}Maar zelfs in deze vorm loste het niet het hele probleem op, dus werd besloten een speciale bibliotheek aan te maken die logberichten naar een bestand zou schrijven. Ze deed het op een slimme manier en bood de flexibiliteit om filters te configureren voor gelogde gebeurtenissen en gegevens.
Het hele logproces bestaat in feite uit drie delen:
- Het eerste deel is het verzamelen van informatie .
- Het tweede deel is het filteren van de verzamelde informatie.
- Het derde deel is de opname van de geselecteerde informatie.
1.3 Inleiding tot de log4j-logger
De eerste populaire logger in de Java-gemeenschap was de log4j. Het opnemen in het project is heel eenvoudig, hiervoor hoef je slechts een paar regels toe te voegen aan je pom.xml
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>2.2.17</version>
</dependency>De interactie van je programma met zo'n logger ziet er ongeveer zo uit:
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}Er gebeuren hier drie dingen:
De creatie van het object wordt groen gemarkeerd Logger . Het object wordt opgeslagen in een statische variabele om er gemakkelijk mee te kunnen werken. En ook getLogger()informatie over de klasse waarin de informatie wordt verzameld, wordt doorgegeven aan de methode.
Op de blauw gemarkeerde regel loggen we informatie van waarde alleen tijdens het debuggen . Hiervoor wordt een speciale methode gebruikt -debug()
En tot slot is de regel waar we de uitzondering opslaan die in het logboek is ontstaan, rood gemarkeerd . Uitzonderingen zijn mogelijke fouten, dus de error().