Java Academy · Lekcja

Fasada SLF4J i loggery

Logowanie na właściwym poziomie

Fasada SLF4J i loggery to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Czym jest SLF4J?

SLF4J (Simple Logging Facade for Java) to abstrakcja. Kod korzysta z jego API, a backend, taki jak Logback lub Log4j2, wykonuje właściwe logowanie.

Dzięki temu biblioteki mogą logować komunikaty bez narzucania aplikacji konkretnej implementacji.

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

Uzyskiwanie loggera

Utwórz jeden logger dla każdej klasy za pomocą LoggerFactory.getLogger(MyClass.class).

Zgodnie z konwencją pole ma modyfikatory private static final i nosi nazwę log lub logger. Klasa staje się nazwą loggera, która pojawia się w danych wyjściowych.

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

Pięć poziomów

Loggery SLF4J udostępniają jedną metodę dla każdego poziomu:

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

Wybór właściwego poziomu

Wskazówki:

ERROR: rzeczywista awaria, którą człowiek musi się zająć.
WARN: anomalia, z której można się odzyskać.
INFO: istotne zdarzenia cyklu życia.
DEBUG: diagnostyka dla programistów, wyłączona na produkcji.
TRACE: niezwykle szczegółowe śledzenie działania.

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

Nazwy loggerów i hierarchia

Nazwy loggerów tworzą hierarchię na podstawie pakietów rozdzielonych kropkami. Logger o nazwie com.example.svc jest potomkiem com.example.

Konfiguracja rodzica jest stosowana do elementów potomnych, chyba że zostanie nadpisana, dlatego można ustawiać poziomy dla poszczególnych pakietów.

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

Warunkowanie kosztownych wywołań

W przypadku kosztownego tworzenia komunikatu użyj isDebugEnabled(), aby praca była wykonywana tylko wtedy, gdy dany poziom jest aktywny.

W przypadku logowania z parametrami (omówionego w następnej części) rzadko jest to potrzebne, ale ma kluczowe znaczenie przy samodzielnym tworzeniu ciągów znaków.

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

Logowanie wyjątków

Aby zapisać wyjątek wraz z pełnym śladem stosu, przekaż Throwable jako ostatni argument.

Nie umieszczaj wyjątku w placeholderze — przekaż go po komunikacie.

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

Jeden logger na klasę

Zadeklaruj logger raz jako pole static final. Nigdy nie twórz loggera wewnątrz metody, ponieważ powoduje to niepotrzebną pracę i pozbawia Cię korzyści wynikającej z nazwy klasy.

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 a backend

SLF4J to tylko API. W czasie działania wiąże się z backendem, który znajduje się na ścieżce klas.

Dodaj logback-classic: SLF4J korzysta z Logback.
Dodaj log4j-slf4j2-impl: SLF4J korzysta z Log4j2.

Twój kod nigdy się nie zmienia.

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

Unikaj logowania danych wrażliwych

Nigdy nie loguj haseł, tokenów ani pełnych numerów kart kredytowych. Logi są często przesyłane do wielu systemów i przechowywane przez długi czas.

Przed zalogowaniem zamaskuj lub pomiń pola zawierające dane wrażliwe.

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

Realistyczna usługa

Połączmy wszystko: niewielka usługa logująca komunikaty na odpowiednich poziomach i obsługująca ścieżkę z wyjątkiem.

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

Szybki test

Sprawdź swoją podstawową wiedzę o SLF4J.

Podsumowanie

Poznali Państwo fasadę SLF4J:

Dla każdej klasy pobieraj jeden logger private static final Logger.
Odpowiednio korzystaj z pięciu metod poziomów.
Nazwy loggerów tworzą hierarchię, co umożliwia kontrolę na poziomie pakietów.
Przekazuj Throwable jako ostatni argument, aby logować ślady stosu; nigdy nie loguj sekretów.

W następnej części omówiono wydajne komunikaty z parametrami.

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

Często zadawane pytania

Czy lekcja „Fasada SLF4J i loggery” jest bezpłatna?

Tak — pełny tekst „Fasada SLF4J i loggery” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Fasada SLF4J i loggery”?

Logowanie na właściwym poziomie Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Fasada SLF4J i loggery”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy