Java Academy · Lezione

Perché usare il logging strutturato

Oltre System.out.println

Perché usare il logging strutturato è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Il problema con println

System.out.println va bene per un esperimento rapido, ma è uno strumento di logging inadeguato per le applicazioni reali.

Nessun timestamp, livello o nome del thread.
Nessun modo per disattivarlo in produzione.
Scrive solo su stdout, senza possibilità di instradamento.

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

Cosa aggiungono i framework di logging

Un framework di logging offre:

Livelli (TRACE, DEBUG, INFO, WARN, ERROR) per filtrare il rumore.
Timestamp, thread e nomi dei logger automaticamente.
Instradamento verso file, console o sistemi remoti.
Configurazione a runtime senza ricompilare.

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

Spiegazione dei livelli di log

I livelli classificano i messaggi in base all'importanza:

TRACE: dettagli molto specifici.
DEBUG: diagnostica per lo sviluppo.
INFO: normali traguardi operativi.
WARN: qualcosa di imprevisto, ma recuperabile.
ERROR: un errore che richiede attenzione.

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

Filtrare in base alla soglia

Un logger ha una soglia. I messaggi al di sotto della soglia vengono scartati in modo economico.

In produzione potrebbe impostare INFO, così DEBUG e TRACE scompaiono, riducendo rumore e costi senza modificare il codice.

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

Strutturato e non strutturato

I log non strutturati sono semplici frasi. I log strutturati aggiungono contesto sotto forma di coppie chiave-valore (ID utente, ID richiesta) che le macchine possono analizzare.

I log strutturati sono ricercabili e aggregabili in strumenti come Elasticsearch o 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);
    }
}

L'idea della facade

Il codice non dovrebbe dipendere da una libreria di logging specifica. Una facade come SLF4J consente di programmare usando una sola API e di sostituire in seguito il backend (Logback, Log4j2).

In questo modo l'applicazione rimane disaccoppiata dalle scelte relative all'implementazione del logging.

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

Perché non usare semplicemente un flag booleano?

Alcuni codici usano if (DEBUG) System.out.println(...). Questo dissemina il codice di istruzioni aggiuntive e non offre alcun controllo per pacchetto.

Un framework di logging centralizza la configurazione: abilita DEBUG per un pacchetto e ERROR per tutto il resto.

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

Considerazioni sulle prestazioni

Il logging dovrebbe essere poco costoso quando è disabilitato. I framework evitano il lavoro relativo ai livelli filtrati e i messaggi parametrizzati impediscono di costruire stringhe che verrebbero subito scartate.

println valuta sempre il proprio argomento, anche se nessuno legge l'output.

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

Instradamento centralizzato dell'output

I framework inviano i log a uno o più appender: console, file con rotazione, syslog o un collector di rete.

Si configura l'instradamento una sola volta; il codice dell'applicazione rimane invariato.

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

Correlazione e contesto

I sistemi reali aggiungono un ID richiesta a ogni riga di log relativa a una richiesta, così è possibile seguire il percorso di un utente tra thread e servizi.

SLF4J supporta questa funzionalità tramite 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);
    }
}

Il programma

Durante questo corso:

Utilizzerà la facade SLF4J e recupererà i logger.
Scriverà i log al livello appropriato.
Utilizzerà messaggi parametrizzati per una maggiore efficienza.
Configurerà Logback con appender e pattern.

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

Verifica rapida

Verifichi la Sua comprensione del logging strutturato.

Riepilogo

Ha appreso perché il logging strutturato è importante:

println non offre livelli, metadati né instradamento.
I framework aggiungono livelli, filtraggio e appender.
Una facade disaccoppia il codice dal backend.
Il contesto strutturato e MDC consentono la correlazione.

Successivamente, la facade SLF4J e la creazione dei logger.

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

Domande Frequenti

La lezione «Perché usare il logging strutturato» è gratuita?

Sì — il testo completo di «Perché usare il logging strutturato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Perché usare il logging strutturato»?

Oltre System.out.println Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Perché usare il logging strutturato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy