Java Academy · Lektion

Parameteriserad loggning

Effektiv formatering av meddelanden.

Lektion 3 av 413 steg

Parameteriserad loggning är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 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 strängkonkatenering

När du konkatenerar ett loggmeddelande byggs hela strängen innan anropet görs, även om nivån är inaktiverad.

log.debug("id=" + id + " name=" + name) slösar CPU när DEBUG är avstängt, eftersom strängen byggs oavsett.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        String name = "Ada"; int id = 7;
        // Bad: string is built even if DEBUG is disabled
        log.debug("id=" + id + " name=" + name);
    }
}

Platshållare med {}

SLF4J använder {} som platshållare. Skicka värdena som ytterligare argument.

Meddelandet sätts bara ihop om nivån är aktiverad, så inaktiverad loggning kostar nästan ingenting.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        String name = "Ada"; int id = 7;
        // Good: no string built unless DEBUG is on
        log.debug("id={} name={}", id, name);
    }
}

Flera platshållare

Platshållare fylls i ordning. Den första {} tar det första argumentet, den andra tar det andra och så vidare.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("order {} for user {} totaling {} cents", "A-1", 42, 1599);
    }
}

Varför det är effektivt

Ramverket kontrollerar först nivån. Om den är inaktiverad returnerar det omedelbart utan att anropa toString() på något argument.

Den kostsamma delen, formateringen, sker först när meddelandet faktiskt ska skickas ut.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String describe(Object o) { System.out.println("toString called"); return o.toString(); }
    public static void main(String[] args) {
        // Note: passing describe(...) still evaluates eagerly; pass the raw object instead
        log.trace("value={}", new int[]{1, 2, 3});
    }
}

Skicka råobjekt, inte förformaterade strängar

För att dra nytta av fördröjningen ska du skicka råobjektet, inte ett metodanrop som formaterar det.

Om du skriver log.debug("{}", buildReport()) körs buildReport() fortfarande direkt. Skicka argument som loggern kan formatera själv.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        Object user = new Object();
        // Logger calls user.toString() only if DEBUG is enabled
        log.debug("current user: {}", user);
    }
}

Lata suppliers för tungt arbete

När formateringen faktiskt är kostsam använder du SLF4J 2.x:s fluent API med en Supplier, så att arbetet skjuts upp.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String heavyReport() { return "...expensive..."; }
    public static void main(String[] args) {
        log.atDebug()
           .setMessage("report: {}")
           .addArgument(() -> heavyReport())
           .log();
    }
}

Escapa en bokstavlig klammerparentes

Om du behöver en bokstavlig {} i meddelandet escaper du den med ett omvänt snedstreck: \\{}.

Detta är ovanligt, men användbart när du loggar JSON-liknande text.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        // Logs a literal {} then the value
        log.info("empty object is \\{} and id is {}", 7);
    }
}

Undantag med platshållare

Du kan kombinera platshållare med ett efterföljande undantag. SLF4J identifierar att det sista argumentet är ett Throwable och skriver ut dess stackspårning.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        int id = 99;
        try {
            throw new RuntimeException("db down");
        } catch (Exception e) {
            log.error("failed processing record {}", id, e);
        }
    }
}

Undvik för många argument

Om antalet platshållare och antalet argument inte stämmer överens gör SLF4J sitt bästa, men utdata kan se felaktig ut.

Se till att de hålls synkroniserade. För fler än ett par värden kan du i stället överväga strukturerad kontext (MDC).

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        // Two placeholders, two arguments: correct
        log.info("user {} did {}", "ada", "login");
    }
}

Lägg till kontext med MDC

För värden som delas av många rader, till exempel ett begärande-ID, lägger du in dem i MDC i stället för i varje meddelande.

Mönsterlayouten kan sedan automatiskt skriva ut MDC-värdet på varje rad.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        MDC.put("requestId", "req-1234");
        try {
            log.info("handling request");
            log.info("request done");
        } finally {
            MDC.clear();
        }
    }
}

Sammanfattning av bästa praxis

Regler för effektiv loggning:

Använd alltid platshållare med {}, aldrig konkatenering med +.
Skicka råobjekt, inte färdigbyggda strängar.
Använd suppliers eller isXEnabled() för verkligt tungt arbete.
Använd MDC för övergripande kontext.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("processed {} items in {} ms", 1000, 42);
    }
}

Snabbtest

Testa dina kunskaper i parametriserad loggning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig parametriserad loggning:

Använd platshållare med {} och ytterligare argument.
Meddelanden byggs fördröjt, bara när nivån är aktiverad.
Skicka råobjekt; använd suppliers för tungt arbete.
Använd MDC för delade kontextvärden.

Härnäst går vi igenom hur Logback-backend-systemet konfigureras.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("Parameterized logging recap: {}", "done");
    }
}

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 ”Parameteriserad loggning” gratis?

Ja – hela texten till ”Parameteriserad 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 ”Parameteriserad loggning”?

Effektiv formatering av meddelanden. 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 3 av 4.

Hur lång tid tar lektionen ”Parameteriserad 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