Java Academy · Lezione

Facade e logger SLF4J

Registrare i log al livello appropriato

Facade e logger SLF4J è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Che cos'è SLF4J?

SLF4J (Simple Logging Facade for Java) è un'astrazione. Il codice viene scritto sulla sua API, mentre un backend come Logback o Log4j2 esegue effettivamente il logging.

Questo consente alle librerie di eseguire il logging senza imporre all'applicazione un'implementazione specifica.

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

Ottenere un logger

Crei un logger per ogni classe con LoggerFactory.getLogger(MyClass.class).

Per convenzione, il campo è private static final e si chiama log o logger. La classe diventa il nome del logger, che compare nell'output.

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

public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
    void placeOrder(String id) {
        log.info("Placing order {}", id);
    }
}

I cinque livelli

I logger SLF4J espongono un metodo per ogni livello:

log.trace(...)
log.debug(...)
log.info(...)
log.warn(...)
log.error(...)

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.trace("entering main");
        log.debug("args length = {}", args.length);
        log.info("service is up");
        log.warn("cache miss");
        log.error("failed to connect");
    }
}

Scegliere il livello corretto

Indicazioni:

ERROR: un errore effettivo che richiede l'intervento di una persona.
WARN: un'anomalia recuperabile.
INFO: eventi significativi del ciclo di vita.
DEBUG: diagnostica per sviluppatori, disattivata in produzione.
TRACE: tracing estremamente dettagliato.

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

public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);
    void charge(int cents) {
        if (cents <= 0) { log.warn("non-positive charge: {}", cents); return; }
        log.info("charged {} cents", cents);
    }
}

Nomi e gerarchia dei logger

I nomi dei logger sono gerarchici in base ai pacchetti separati da punti. Un logger denominato com.example.svc è figlio di com.example.

La configurazione di un logger padre si applica ai figli se non viene sovrascritta, quindi è possibile impostare i livelli per pacchetto.

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

public class Main {
    public static void main(String[] args) {
        Logger a = LoggerFactory.getLogger("com.example.app");
        Logger b = LoggerFactory.getLogger("com.example.app.db");
        a.info("parent logger");
        b.debug("child inherits parent's level unless overridden");
    }
}

Proteggere le chiamate costose

Per la costruzione costosa dei messaggi, utilizzi isDebugEnabled() come controllo, in modo che l'operazione venga eseguita solo quando il livello è attivo.

Con il logging parametrizzato (nella prossima lezione) raramente è necessario, ma è essenziale quando si costruiscono autonomamente le stringhe.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String heavyDump() { return "...large state..."; }
    public static void main(String[] args) {
        if (log.isDebugEnabled()) {
            log.debug("state: {}", heavyDump());
        }
    }
}

Registrare le eccezioni

Per registrare un'eccezione con l'intero stack trace, passi il Throwable come ultimo argomento.

Non inserisca l'eccezione in un segnaposto; la passi dopo il messaggio.

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) {
        try {
            throw new IllegalStateException("boom");
        } catch (Exception e) {
            log.error("Operation failed for id {}", 42, e);
        }
    }
}

Un logger per classe

Dichiari il logger una sola volta come campo static final. Non crei mai un logger all'interno di un metodo: spreca risorse e fa perdere il vantaggio del nome della classe.

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

public class UserRepository {
    // Good: one shared logger named after the class
    private static final Logger log = LoggerFactory.getLogger(UserRepository.class);
    void save(String user) { log.debug("saving {}", user); }
}

SLF4J e il backend

SLF4J è solo l'API. In fase di esecuzione si collega al backend presente nel classpath.

Aggiunga logback-classic: SLF4J utilizza Logback.
Aggiunga log4j-slf4j2-impl: SLF4J utilizza Log4j2.

Il codice non cambia mai.

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) {
        // Same code, different backend depending on classpath
        log.info("backend-agnostic logging");
    }
}

Evitare di registrare dati sensibili

Non registri mai password, token o numeri completi di carte di credito. I log vengono spesso inviati a molti sistemi e conservati a lungo.

Mascheri o ometta i campi sensibili prima di registrare i dati.

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    static String mask(String card) { return "****" + card.substring(card.length() - 4); }
    public static void main(String[] args) {
        log.info("charged card {}", mask("4111111111111234"));
    }
}

Un servizio realistico

Riunendo i concetti: un piccolo servizio che registra eventi ai livelli appropriati e gestisce un percorso con eccezione.

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

public class EmailService {
    private static final Logger log = LoggerFactory.getLogger(EmailService.class);
    void send(String to) {
        log.debug("preparing email to {}", to);
        try {
            if (to == null) throw new IllegalArgumentException("null recipient");
            log.info("email sent to {}", to);
        } catch (Exception e) {
            log.error("failed to send email", e);
        }
    }
}

Verifica rapida

Verifichi le Sue conoscenze di base di SLF4J.

Riepilogo

Ha appreso il funzionamento della facade SLF4J:

Ottenga un private static final Logger per ogni classe.
Utilizzi in modo appropriato i metodi dei cinque livelli.
I nomi dei logger sono gerarchici per consentire il controllo per pacchetto.
Passi un Throwable come ultimo argomento per registrare gli stack trace; non registri mai segreti.

Successivamente, i messaggi parametrizzati efficienti.

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("SLF4J facade recap complete");
    }
}

Domande Frequenti

La lezione «Facade e logger SLF4J» è gratuita?

Sì — il testo completo di «Facade e logger SLF4J» è 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 «Facade e logger SLF4J»?

Registrare i log al livello appropriato 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 2 di 4.

Quanto tempo richiede la lezione «Facade e logger SLF4J»?

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