Java Academy · Lektion

SLF4J-Fassade und Logger

Auf der richtigen Ebene loggen

SLF4J-Fassade und Logger ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist SLF4J?

SLF4J (Simple Logging Facade for Java) ist eine Abstraktion. Sie programmieren gegen dessen API, und ein Backend wie Logback oder Log4j2 übernimmt das eigentliche Logging.

Dadurch können Bibliotheken Logging verwenden, ohne der Anwendung eine bestimmte Implementierung aufzuzwingen.

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

Einen Logger beziehen

Erstellen Sie pro Klasse einen Logger mit LoggerFactory.getLogger(MyClass.class).

Konventionell ist das Feld private static final und heißt log oder logger. Die Klasse wird zum Namen des Loggers, der in der Ausgabe erscheint.

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

Die fünf Log-Level

SLF4J-Logger stellen für jedes Level eine Methode bereit:

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

Das richtige Level auswählen

Richtlinien:

ERROR: ein echter Fehler, den ein Mensch untersuchen muss.
WARN: eine behebbare Anomalie.
INFO: wichtige Ereignisse im Lebenszyklus.
DEBUG: Diagnoseinformationen für Entwickler, in der Produktion deaktiviert.
TRACE: äußerst ausführliches Tracing.

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

Logger-Namen und Hierarchie

Logger-Namen sind anhand von durch Punkte getrennten Paketen hierarchisch aufgebaut. Ein Logger mit dem Namen com.example.svc ist ein untergeordneter Logger von com.example.

Die Konfiguration eines übergeordneten Loggers gilt für untergeordnete Logger, sofern sie nicht überschrieben wird. So können Sie Level pro Paket festlegen.

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

Aufwendige Aufrufe absichern

Bei der aufwendigen Erstellung von Nachrichten sollten Sie diese mit isDebugEnabled() absichern, damit die Arbeit nur ausgeführt wird, wenn das Level aktiv ist.

Bei parametrisiertem Logging (in der nächsten Lektion) benötigen Sie das nur selten, aber beim manuellen Erstellen von Strings ist es unerlässlich.

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

Exceptions protokollieren

Um eine Exception mit ihrem vollständigen Stacktrace zu protokollieren, übergeben Sie das Throwable als letztes Argument.

Setzen Sie die Exception nicht in einen Platzhalter, sondern übergeben Sie sie nach der Nachricht.

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

Ein Logger pro Klasse

Deklarieren Sie den Logger einmal als statisches finales Feld. Erstellen Sie niemals einen Logger innerhalb einer Methode. Das verursacht unnötigen Aufwand und lässt den Vorteil des Klassennamens verloren gehen.

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 und das Backend

SLF4J ist nur die API. Zur Laufzeit wird es an das Backend gebunden, das sich im Klassenpfad befindet.

Fügen Sie logback-classic hinzu: SLF4J verwendet Logback.
Fügen Sie log4j-slf4j2-impl hinzu: SLF4J verwendet Log4j2.

Ihr Code bleibt unverändert.

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

Keine sensiblen Daten protokollieren

Protokollieren Sie niemals Passwörter, Tokens oder vollständige Kreditkartennummern. Logs werden oft an viele Systeme übertragen und lange aufbewahrt.

Maskieren oder entfernen Sie sensible Felder, bevor Sie sie protokollieren.

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

Ein realistischer Dienst

Alles zusammen: Ein kleiner Dienst protokolliert mit geeigneten Leveln und verfügt über einen Pfad für 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);
        }
    }
}

Kurzer Test

Testen Sie Ihre Grundlagen zu SLF4J.

Zusammenfassung

Sie haben die SLF4J-Fassade kennengelernt:

Beziehen Sie pro Klasse einen private static final Logger.
Verwenden Sie die fünf Level-Methoden passend.
Logger-Namen sind für die paketweise Steuerung hierarchisch aufgebaut.
Übergeben Sie ein Throwable zuletzt, um Stacktraces zu protokollieren, und protokollieren Sie niemals Geheimnisse.

Als Nächstes folgen effiziente parametrisierte Nachrichten.

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

Häufig gestellte Fragen

Ist die Lektion „SLF4J-Fassade und Logger“ kostenlos?

Ja — der vollständige Text von „SLF4J-Fassade und Logger“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „SLF4J-Fassade und Logger“?

Auf der richtigen Ebene loggen Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „SLF4J-Fassade und Logger“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy