Java Academy · Lekcja

Dlaczego logowanie strukturalne

Coś więcej niż System.out.println

Dlaczego logowanie strukturalne to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 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.

Problem z println

System.out.println sprawdza się podczas szybkiego eksperymentu, ale jest słabym narzędziem do rejestrowania zdarzeń w rzeczywistych aplikacjach.

Brak znaczników czasu, poziomów i nazw wątków.
Brak możliwości wyłączenia go w środowisku produkcyjnym.
Zapisuje wyłącznie na stdout, bez możliwości kierowania danych wyjściowych.

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

Co dodają frameworki logowania

Framework logowania zapewnia:

Poziomy (TRACE, DEBUG, INFO, WARN, ERROR) do filtrowania zbędnych komunikatów.
Automatyczne dodawanie znaczników czasu, nazw wątków i loggerów.
Kierowanie logów do plików, konsoli lub systemów zdalnych.
Konfigurację w czasie działania bez ponownej kompilacji.

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

Wyjaśnienie poziomów logowania

Poziomy porządkują komunikaty według ich ważności:

TRACE: bardzo szczegółowe informacje.
DEBUG: diagnostyka używana podczas tworzenia oprogramowania.
INFO: standardowe kamienie milowe.
WARN: coś nieoczekiwanego, ale możliwego do naprawienia.
ERROR: błąd wymagający uwagi.

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

Filtrowanie według progu

Logger ma próg. Komunikaty poniżej tego progu są odrzucane przy niewielkim koszcie.

W środowisku produkcyjnym można ustawić poziom INFO, aby DEBUG i TRACE znikały, ograniczając liczbę komunikatów i koszty bez zmiany kodu.

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

Logi strukturalne a niestrukturalne

Logi niestrukturalne są zwykłymi zdaniami. Logi strukturalne zawierają kontekst w postaci par klucz-wartość (identyfikator użytkownika, identyfikator żądania), który mogą analizować komputery.

Logi strukturalne można przeszukiwać i agregować za pomocą narzędzi takich jak Elasticsearch czy 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);
    }
}

Idea fasady

Nie należy wiązać kodu z konkretną biblioteką logowania. Fasada, taka jak SLF4J, pozwala programować z użyciem jednego API, a później wymienić backend (Logback, Log4j2).

Dzięki temu aplikacja jest niezależna od decyzji dotyczących implementacji logowania.

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

Dlaczego nie użyć po prostu flagi boolean

Część kodu używa konstrukcji if (DEBUG) System.out.println(...). Zanieczyszcza to bazę kodu i nie zapewnia kontroli dla poszczególnych pakietów.

Framework logowania centralizuje konfigurację: można włączyć DEBUG dla jednego pakietu, a dla całej reszty ustawić ERROR.

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

Kwestie wydajności

Logowanie powinno być tanie, gdy jest wyłączone. Frameworki pomijają pracę związaną z odfiltrowanymi poziomami, a komunikaty sparametryzowane pozwalają uniknąć tworzenia ciągów, które zostaną odrzucone.

println zawsze oblicza swój argument, nawet jeśli nikt nie odczyta wyniku.

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

Centralne kierowanie danych wyjściowych

Frameworki wysyłają logi do jednego lub większej liczby appenderów: konsoli, rotowanych plików, syslogu lub sieciowego kolektora.

Kierowanie konfiguruje się raz, a kod aplikacji pozostaje bez zmian.

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

Korelacja i kontekst

Rzeczywiste systemy dodają identyfikator żądania do każdego wiersza logu w ramach żądania, dzięki czemu można śledzić drogę jednego użytkownika między wątkami i usługami.

SLF4J obsługuje to za pośrednictwem 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);
    }
}

Plan

W trakcie tego kursu:

Użyją Państwo fasady SLF4J i pobiorą loggerów.
Będą Państwo rejestrować komunikaty na właściwym poziomie.
Użyją Państwo komunikatów sparametryzowanych dla większej wydajności.
Skonfigurują Państwo Logback za pomocą appenderów i wzorców.

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

Szybki test

Sprawdź swoją wiedzę na temat logowania strukturalnego.

Podsumowanie

Dowiedzieli się Państwo, dlaczego logowanie strukturalne ma znaczenie:

println nie obsługuje poziomów, metadanych ani routingu.
Frameworki dodają poziomy, filtrowanie i appendery.
Fasada oddziela kod od backendu.
Kontekst strukturalny i MDC umożliwiają korelację.

W następnej części omówiono fasadę SLF4J i tworzenie loggerów.

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

Często zadawane pytania

Czy lekcja „Dlaczego logowanie strukturalne” jest bezpłatna?

Tak — pełny tekst „Dlaczego logowanie strukturalne” 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 „Dlaczego logowanie strukturalne”?

Coś więcej niż System.out.println Ć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 1 z 4.

Ile czasu zajmuje lekcja „Dlaczego logowanie strukturalne”?

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