Java Academy · Leçon

Façade SLF4J et journaliseurs

Journalisez au niveau approprié

Façade SLF4J et journaliseurs est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que SLF4J ?

SLF4J (Façade simple de journalisation pour Java) est une abstraction. Vous programmez avec son API, et une infrastructure comme Logback ou Log4j2 effectue concrètement la journalisation.

Cela permet aux bibliothèques de journaliser sans imposer une implémentation particulière à l'application.

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

Obtenir un journaliseur

Créez un journaliseur par classe avec LoggerFactory.getLogger(MyClass.class).

Par convention, le champ est private static final et s'appelle log ou logger. La classe devient le nom du journaliseur, qui apparaît dans la sortie.

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

Les cinq niveaux

Les journaliseurs SLF4J exposent une méthode par niveau :

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

Choisir le bon niveau

Voici quelques recommandations :

ERROR : une véritable défaillance qu'une personne doit examiner.
WARN : une anomalie à laquelle il est possible de remédier.
INFO : des événements importants du cycle de vie.
DEBUG : des informations de diagnostic pour les développeurs, désactivées en production.
TRACE : un traçage extrêmement détaillé.

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

Noms et hiérarchie des journaliseurs

Les noms des journaliseurs sont hiérarchiques selon les paquets séparés par des points. Un journaliseur nommé com.example.svc est un enfant de com.example.

La configuration d'un parent s'applique aux enfants, sauf indication contraire ; vous pouvez donc définir des niveaux par paquet.

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

Protéger les appels coûteux

Pour la construction coûteuse d'un message, utilisez isDebugEnabled() afin que le travail ne soit effectué que lorsque le niveau est actif.

Avec la journalisation paramétrée (dans la prochaine leçon), vous en aurez rarement besoin, mais c'est essentiel lorsque vous construisez vous-même des chaînes.

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

Journaliser les exceptions

Pour journaliser une exception avec sa trace complète de la pile d'appels, transmettez le Throwable comme dernier argument.

Ne placez pas l'exception dans un paramètre de substitution ; transmettez-la après le message.

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 journaliseur par classe

Déclarez le journaliseur une seule fois dans un champ statique final. Ne créez jamais de journaliseur dans une méthode : cela gaspille du travail et vous fait perdre l'avantage du nom de la 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 et l'infrastructure

SLF4J n'est que l'API. À l'exécution, il se lie à l'infrastructure présente dans le chemin de classes.

Ajoutez logback-classic : SLF4J utilise Logback.
Ajoutez log4j-slf4j2-impl : SLF4J utilise Log4j2.

Votre code ne change jamais.

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

Éviter de journaliser des données sensibles

Ne journalisez jamais de mots de passe, de jetons ou de numéros complets de carte bancaire. Les journaux sont souvent envoyés à de nombreux systèmes et conservés pendant longtemps.

Masquez les champs sensibles ou omettez-les avant la journalisation.

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 service réaliste

Pour tout assembler : un petit service qui journalise avec des niveaux appropriés et comporte un chemin de traitement des exceptions.

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

Vérification rapide

Testez vos connaissances fondamentales de SLF4J.

Récapitulatif

Vous avez découvert la façade SLF4J :

Obtenez un private static final Logger par classe.
Utilisez correctement les méthodes des cinq niveaux.
Les noms des journaliseurs sont hiérarchiques pour permettre un contrôle par paquet.
Transmettez un Throwable en dernier pour journaliser les traces de pile ; ne journalisez jamais de secrets.

Ensuite, les messages paramétrés efficaces.

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

Questions Fréquemment Posées

La leçon « Façade SLF4J et journaliseurs » est-elle gratuite ?

Oui — le texte complet de « Façade SLF4J et journaliseurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Façade SLF4J et journaliseurs » ?

Journalisez au niveau approprié Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Façade SLF4J et journaliseurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Pourquoi utiliser la journalisation structurée
Façade SLF4J et journaliseurs
Journalisation paramétrée
Configurer Logback

← Retour à Java Academy