Java Academy · Lektion

Varför strukturerad loggning

Bortom System.out.println.

Lektion 1 av 413 steg

Varför strukturerad loggning är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Problemet med println

System.out.println fungerar bra för ett snabbt experiment, men är ett dåligt loggningsverktyg för riktiga program.

Inga tidsstämplar, nivåer eller trådnamn.
Det går inte att stänga av i produktion.
Skriver endast till stdout, utan någon dirigering.

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

Vad loggningsramverk tillför

Ett loggningsramverk ger dig:

Nivåer (TRACE, DEBUG, INFO, WARN, ERROR) för att filtrera bort brus.
Tidsstämplar, tråd- och loggningsnamn automatiskt.
Dirigering till filer, konsolen eller fjärrsystem.
Konfiguration under körning utan omkompilering.

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);
    }
}

Förklaring av loggningsnivåer

Nivåerna rangordnar meddelanden efter betydelse:

TRACE: mycket detaljerad information.
DEBUG: utvecklingsdiagnostik.
INFO: normala milstolpar.
WARN: något oväntat men återställningsbart.
ERROR: ett fel som kräver åtgärd.

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);
        }
    }
}

Filtrering efter tröskelvärde

En logger har ett tröskelvärde. Meddelanden under tröskeln filtreras bort med liten kostnad.

I produktion kan du ange INFO så att DEBUG och TRACE försvinner, vilket minskar brus och kostnader utan kodändringar.

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");
    }
}

Strukturerad kontra ostrukturerad

Ostrukturerade loggar är vanliga meningar. Strukturerade loggar innehåller nyckel-värde-kontext (användar-ID, begärande-ID) som maskiner kan tolka.

Strukturerade loggar är sökbara och kan aggregeras i verktyg som Elasticsearch eller 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);
    }
}

Tanken bakom fasader

Du bör inte binda koden till ett specifikt loggningsbibliotek. En fasad som SLF4J låter dig programmera mot ett API och byta backend (Logback, Log4j2) senare.

Detta frikopplar programmet från valen av loggningsimplementation.

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");
    }
}

Varför inte bara använda en boolesk flagga?

Viss kod använder if (DEBUG) System.out.println(...). Det skräpar ned kodbasen och ger ingen kontroll per paket.

Ett loggningsramverk centraliserar konfigurationen: aktivera DEBUG för ett paket och ERROR för allt annat.

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");
    }
}

Prestandaaspekter

Loggning bör vara billig när den är inaktiverad. Ramverk hoppar över arbete för filtrerade nivåer, och parametriserade meddelanden undviker att bygga strängar som du ändå kastar bort.

println utvärderar alltid sitt argument, även om ingen läser resultatet.

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");
    }
}

Centraliserad utmatningsdirigering

Ramverk skickar loggar till en eller flera appenders: konsolen, rullande filer, syslog eller en nätverksinsamlare.

Du konfigurerar dirigeringen en gång; programkoden förblir densamma.

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);
    }
}

Korrelatering och kontext

I riktiga system läggs ett request-id till på varje loggrad för en begäran, så att du kan spåra en användares resa över trådar och tjänster.

SLF4J stöder detta via 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);
    }
}

Planen

Under den här kursen kommer du att:

Använda SLF4J-fasaden och hämta loggers.
Logga på rätt nivå.
Använda parametriserade meddelanden för effektivitet.
Konfigurera Logback med appenders och mönster.

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

Snabbtest

Testa din förståelse av strukturerad loggning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig varför strukturerad loggning är viktig:

println saknar nivåer, metadata och routing.
Ramverk lägger till nivåer, filtrering och appenders.
En fasad frikopplar koden från backend-systemet.
Strukturerad kontext och MDC möjliggör korrelation.

Härnäst går vi igenom SLF4J-fasaden och hur du skapar loggers.

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

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Varför strukturerad loggning” gratis?

Ja – hela texten till ”Varför strukturerad loggning” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Varför strukturerad loggning”?

Bortom System.out.println. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Varför strukturerad loggning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy