Java Academy · Les

Waarom structured logging

Verder kijken dan System.out.println

Les 1 van 413 stappen

Waarom structured logging is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Het probleem met println

System.out.println is prima voor een snel experiment, maar een slecht hulpmiddel voor logregistratie in echte toepassingen.

Geen tijdstempels, niveaus of threadnamen.
Geen manier om het in productie uit te schakelen.
Schrijft alleen naar stdout, zonder routering.

public class Main {
    public static void main(String[] args) {
        // Crude: no level, no timestamp, always on
        System.out.println("User logged in");
    }
}

Wat frameworks voor logregistratie toevoegen

Een framework voor logregistratie biedt:

Niveaus (TRACE, DEBUG, INFO, WARN, ERROR) om ruis te filteren.
Tijdstempels, thread- en loggernamen automatisch.
Routering naar bestanden, console of externe systemen.
Configuratie tijdens de uitvoering zonder opnieuw te compileren.

public class Main {
    public static void main(String[] args) {
        // A framework would render: time, level, logger, thread, message
        String simulated = "2026-01-01 10:00:00 INFO  c.e.App [main] - User logged in";
        System.out.println(simulated);
    }
}

Logniveaus uitgelegd

Niveaus rangschikken berichten op belangrijkheid:

TRACE: zeer gedetailleerde informatie.
DEBUG: diagnostiek voor ontwikkeling.
INFO: normale mijlpalen.
WARN: iets onverwachts maar herstelbaars.
ERROR: een fout die aandacht nodig heeft.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    public static void main(String[] args) {
        Level threshold = Level.INFO;
        for (Level l : Level.values()) {
            boolean shown = l.ordinal() >= threshold.ordinal();
            System.out.println(l + " visible? " + shown);
        }
    }
}

Filteren op drempelwaarde

Een logger heeft een drempelwaarde. Berichten onder die drempel worden goedkoop genegeerd.

In productie kun je bijvoorbeeld INFO instellen, zodat DEBUG en TRACE verdwijnen. Zo verminder je ruis en kosten zonder wijzigingen in de code.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    static void log(Level threshold, Level level, String msg) {
        if (level.ordinal() >= threshold.ordinal()) {
            System.out.println(level + " - " + msg);
        }
    }
    public static void main(String[] args) {
        Level t = Level.WARN;
        log(t, Level.DEBUG, "hidden detail");
        log(t, Level.ERROR, "shown error");
    }
}

Gestructureerd versus ongestructureerd

Ongestructureerde logberichten zijn gewone zinnen. Gestructureerde logberichten voegen sleutel-waardecontext toe (gebruikers-id, verzoek-id) die machines kunnen parseren.

Gestructureerde logberichten zijn doorzoekbaar en kunnen worden geaggregeerd in tools zoals Elasticsearch of Loki.

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Structured context as key-value pairs
        Map<String, Object> fields = Map.of("event", "login", "userId", 42, "ok", true);
        System.out.println(fields);
    }
}

Het façade-idee

Je moet je code niet aan een specifieke bibliotheek voor logregistratie koppelen. Een façade zoals SLF4J laat je programmeren tegen één API en later de backend (Logback, Log4j2) verwisselen.

Hierdoor wordt je toepassing losgekoppeld van keuzes voor de implementatie van logregistratie.

public class Main {
    public static void main(String[] args) {
        // Concept: your code calls a facade interface, not a concrete logger
        System.out.println("App -> SLF4J facade -> Logback backend");
    }
}

Waarom niet gewoon een Booleaanse vlag?

Sommige code gebruikt if (DEBUG) System.out.println(...). Dit vervuilt de codebasis en biedt geen controle per pakket.

Een framework voor logregistratie centraliseert de configuratie: schakel DEBUG in voor één pakket en ERROR voor al het andere.

public class Main {
    static final boolean DEBUG = false;
    public static void main(String[] args) {
        // Inflexible: one global switch, scattered checks
        if (DEBUG) System.out.println("diagnostic");
        System.out.println("A framework controls this per logger instead");
    }
}

Prestatieproblemen

Logregistratie moet goedkoop zijn wanneer deze is uitgeschakeld. Frameworks slaan werk voor gefilterde niveaus over en geparametriseerde berichten voorkomen dat je tekenreeksen opbouwt die je weggooit.

println evalueert zijn argument altijd, zelfs als niemand de uitvoer leest.

public class Main {
    static String expensive() {
        System.out.println("(building expensive string)");
        return "big report";
    }
    public static void main(String[] args) {
        boolean debugEnabled = false;
        // Only build the message if it will actually be logged
        if (debugEnabled) System.out.println(expensive());
        System.out.println("skipped expensive work");
    }
}

Gecentraliseerde uitvoerroutering

Frameworks sturen logberichten naar een of meer uitvoerkanalen: console, roterende bestanden, syslog of een netwerkverzamelaar.

Je configureert de routering één keer; de toepassingscode blijft hetzelfde.

public class Main {
    public static void main(String[] args) {
        String[] appenders = {"CONSOLE", "ROLLING_FILE", "JSON_HTTP"};
        for (String a : appenders) System.out.println("route logs to: " + a);
    }
}

Correlatie en context

Echte systemen voegen aan elke logregel in een verzoek een verzoek-id toe, zodat je de route van één gebruiker door threads en services kunt volgen.

SLF4J ondersteunt dit via de MDC (Mapped Diagnostic Context).

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, String> mdc = new HashMap<>();
        mdc.put("requestId", "req-1234");
        System.out.println("All logs in this request tagged with " + mdc);
    }
}

Het plan

Tijdens deze cursus ga je:

De SLF4J-façade gebruiken en loggers ophalen.
Logberichten op het juiste niveau registreren.
Geparametriseerde berichten gebruiken voor efficiëntie.
Logback configureren met uitvoerkanalen en patronen.

public class Main {
    public static void main(String[] args) {
        System.out.println("Next: SLF4J facade and loggers");
    }
}

Korte controle

Controleer je begrip van gestructureerde logboekregistratie.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd waarom gestructureerde logboekregistratie belangrijk is:

println heeft geen niveaus, metagegevens en routering.
Raamwerken voegen niveaus, filtering en appenders toe.
Een abstractielaag koppelt code los van het achterliggende systeem.
Gestructureerde context en MDC maken correlatie mogelijk.

Hierna behandel je de abstractielaag van SLF4J en het maken van loggers.

public class Main {
    public static void main(String[] args) {
        System.out.println("Structured logging recap complete");
    }
}

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Waarom structured logging” gratis?

Ja — de volledige tekst van “Waarom structured logging” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Waarom structured logging”?

Verder kijken dan System.out.println Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Waarom structured logging”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy