Java Academy · Lekcja

Przypadki użycia: JSON i SQL

Czytelnie osadzaj tekst strukturalny

Przypadki użycia: JSON i SQL to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 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.

Gdzie bloki tekstowe sprawdzają się najlepiej

Bloki tekstowe doskonale nadają się do osadzania tekstu strukturalnego, takiego jak JSON, SQL, HTML i XML. Formaty te często zawierają wiele cudzysłowów i podziałów wierszy, których używanie w zwykłych napisach jest uciążliwe.

Osadzanie JSON

JSON zawiera mnóstwo podwójnych cudzysłowów. W bloku tekstowym nie trzeba ich escapować, więc literał wygląda dokładnie tak jak rzeczywisty JSON.

public class Main {
    public static void main(String[] args) {
        String json = """
            {
              "name": "Alice",
              "age": 30,
              "active": true
            }
            """;
        System.out.print(json);
    }
}

Tablice JSON

Zagnieżdżone tablice i obiekty pozostają czytelne, ponieważ wcięcia odzwierciedlają rzeczywistą strukturę.

public class Main {
    public static void main(String[] args) {
        String json = """
            {
              "colors": ["red", "green", "blue"]
            }
            """;
        System.out.print(json);
    }
}

Osadzanie SQL

Wielowierszowe zapytania SQL stają się przejrzyste i można je łatwo kopiować. Nie trzeba już łączyć fragmentów zawierających przypadkowe spacje.

public class Main {
    public static void main(String[] args) {
        String query = """
            SELECT id, name
            FROM users
            WHERE active = true
            ORDER BY name
            """;
        System.out.print(query);
    }
}

SQL z wartościami w cudzysłowach

Literały napisowe SQL używają pojedynczych cudzysłowów, które nigdy nie kolidują z ogranicznikiem bloku tekstowego, więc pozostają niezmienione.

public class Main {
    public static void main(String[] args) {
        String sql = """
            SELECT * FROM products
            WHERE category = 'books'
            """;
        System.out.print(sql);
    }
}

Budowanie wartości dynamicznych

Aby wstawić wartości w czasie działania programu, należy użyć String.format wraz z symbolami zastępczymi. W rzeczywistych aplikacjach należy unikać ręcznego łączenia zapytań SQL, ale na potrzeby prezentacji to rozwiązanie jest przejrzyste.

public class Main {
    public static void main(String[] args) {
        String template = """
            SELECT * FROM users
            WHERE id = %d
            """;
        String query = String.format(template, 42);
        System.out.print(query);
    }
}

Metoda formatted

Bloki tekstowe dobrze współpracują z metodą instancji formatted(...), która jest skróconą wersją zastosowania String.format do bloku.

public class Main {
    public static void main(String[] args) {
        String json = """
            {"user": "%s", "score": %d}
            """.formatted("Bob", 95);
        System.out.print(json);
    }
}

Osadzanie HTML

Znaczniki HTML z atrybutami używają wielu podwójnych cudzysłowów. Bloki tekstowe pozwalają zachować ich przejrzystość i poprawną składnię.

public class Main {
    public static void main(String[] args) {
        String html = """
            <a href="https://example.com" class="link">
              Click here
            </a>
            """;
        System.out.print(html);
    }
}

Osadzanie XML

Fragmenty konfiguracji XML również świetnie się do tego nadają, ponieważ hierarchia pozostaje widoczna na pierwszy rzut oka.

public class Main {
    public static void main(String[] args) {
        String xml = """
            <config>
              <port>8080</port>
              <debug>true</debug>
            </config>
            """;
        System.out.print(xml);
    }
}

Przetwarzanie osadzonych danych

Po zdefiniowaniu blok należy traktować jak każdy inny napis. W tym przykładzie zliczamy wiersze bloku w stylu CSV.

public class Main {
    public static void main(String[] args) {
        String csv = """
            id,name
            1,Alice
            2,Bob
            """;
        String[] rows = csv.strip().split("\n");
        System.out.println("Data rows: " + (rows.length - 1));
    }
}

Łączenie wielu fragmentów

Większe dokumenty można tworzyć przez formatowanie mniejszych bloków tekstowych i łączenie ich.

public class Main {
    public static void main(String[] args) {
        String row = """
            <li>%s</li>
            """;
        String list = "<ul>\n" + row.formatted("One") + row.formatted("Two") + "</ul>";
        System.out.print(list);
    }
}

Szybkie sprawdzenie

Dlaczego bloki tekstowe są szczególnie wygodne do osadzania JSON?

Podsumowanie

Omówiono praktyczne zastosowania bloków tekstowych:

Świetnie nadają się do JSON, SQL, HTML i XML
Podwójnych cudzysłowów nie trzeba escapować
Do wstawiania wartości należy użyć formatted(...) lub String.format
Wynikiem jest zwykły String, który można analizować lub dzielić
Wcięcia odzwierciedlają rzeczywistą strukturę

Często zadawane pytania

Czy lekcja „Przypadki użycia: JSON i SQL” jest bezpłatna?

Tak — pełny tekst „Przypadki użycia: JSON i SQL” 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 „Przypadki użycia: JSON i SQL”?

Czytelnie osadzaj tekst strukturalny Ć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 4 z 4.

Ile czasu zajmuje lekcja „Przypadki użycia: JSON i SQL”?

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