CodeGym /Kursy /JAVA 25 SELF /Praca ze strukturami dynamicznymi: Map, List, JsonNode

Praca ze strukturami dynamicznymi: Map, List, JsonNode

JAVA 25 SELF
Poziom 46, Lekcja 3
Dostępny

1. Odczyt JSON do Map i List

Zwykle, gdy pracujemy z JSON-em, znamy z góry jego strukturę i możemy opisać ją jako klasę Javy. W praktyce jednak bywa to nieprzewidywalne: pola mogą się pojawiać i znikać, zagnieżdżenie się zmienia. W takich przypadkach o wiele wygodniej operować uniwersalnymi strukturami danych — Map, List — albo drzewami JSON.

Tworzenie modelu Javy dla każdej wariacji — to długie i kruche rozwiązanie. Uniwersalne kolekcje i drzewa pozwalają elastycznie wyciągać tylko potrzebne fragmenty, bez przywiązania do stałego schematu.

Deserializacja obiektu JSON do Map

Przykład JSON:

{
  "id": 123,
  "name": "Alice",
  "email": "alice@example.com",
  "active": true
}

Deserializacja do Map:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws Exception {
        String json = "{\"id\":123,\"name\":\"Alice\",\"email\":\"alice@example.com\",\"active\":true}";

        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> data = mapper.readValue(json, Map.class);

        System.out.println(data);
        // Wyjście: {id=123, name=Alice, email=alice@example.com, active=true}
    }
}

Teraz możesz odwoływać się do dowolnego pola jak do elementu mapy:

System.out.println(data.get("name")); // Alice

Deserializacja tablicy obiektów do List

Tablica JSON:

[
  { "id": 1, "name": "Alice" },
  { "id": 2, "name": "Bob" }
]

Deserializacja:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.Map;

public class UsersReadExample {
    public static void main(String[] args) throws Exception {
        String json = "[{\"id\":1,\"name\":\"Alice\"},{\"id\":2,\"name\":\"Bob\"}]";

        ObjectMapper mapper = new ObjectMapper();
        List<Map<String, Object>> users = mapper.readValue(json, List.class);

        for (Map<String, Object> user : users) {
            System.out.println(user.get("name"));
        }
        // Wyjście:
        // Alice
        // Bob
    }
}

Ważna uwaga: przy odczycie do uniwersalnych struktur wszystkie zagnieżdżone obiekty stają się Map, a tablice — List. Dla złożonych struktur trzeba ostrożnie rzutować typy i je weryfikować:

Object items = data.get("items");
if (items instanceof List) {
    List<?> itemList = (List<?>) items;
    // ...
}

2. JsonNode: drzewo JSON w Jackson

Praca z Map/List jest wygodna, ale nie do końca bezpieczna: łatwo pomylić typ lub pominąć zagnieżdżenie. Jackson oferuje potężniejsze narzędzie — klasę JsonNode. To uniwersalne drzewo, w którym każdy węzeł to obiekt, tablica, wartość albo null.

Pobranie JsonNode

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

public class JsonNodeStart {
    public static void main(String[] args) throws Exception {
        String json = "{\"id\":123,\"name\":\"Alice\",\"tags\":[\"java\",\"json\"]}";
        ObjectMapper mapper = new ObjectMapper();

        JsonNode root = mapper.readTree(json);
        // root — to jest korzeń drzewa JSON
    }
}

Dostęp do pól

int id = root.get("id").asInt();         // 123
String name = root.get("name").asText();  // Alice
JsonNode tags = root.get("tags");         // tablica

System.out.println("Imię: " + name);

Iteracja po tablicy

for (JsonNode tag : tags) {
    System.out.println(tag.asText());
}
// Wyjście:
// java
// json

Zagnieżdżone obiekty

Przykład złożonego JSON:

{
  "user": {
    "id": 1,
    "profile": {
      "nickname": "java_guru",
      "age": 25
    }
  }
}

Wyodrębnienie zagnieżdżonej wartości:

JsonNode profile = root.get("user").get("profile");
String nickname = profile.get("nickname").asText();
System.out.println(nickname); // java_guru

Bezpieczny dostęp: get vs path

- get("key") — jeśli klucza nie ma, zwróci null. Każde wywołanie w rodzaju asText() na null doprowadzi do NullPointerException.
- path("key") — jeśli klucza nie ma, zwróci „pusty” węzeł, i asText() da "", asInt() — 0.

String phone = root.path("phone").asText(); // "" jeśli pola nie ma

Sprawdzenie typu węzła

if (root.has("tags") && root.get("tags").isArray()) {
    for (JsonNode tag : root.get("tags")) {
        // ...
    }
}

Modyfikacja JsonNode

JsonNode — jest niezmienny. Do tworzenia/modyfikacji drzewa używaj ObjectNode/ArrayNode.

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

ObjectMapper mapper = new ObjectMapper();

// Tworzenie nowego obiektu
ObjectNode obj = mapper.createObjectNode();
obj.put("id", 10);
obj.put("name", "Bob");

// Dodawanie tablicy
ArrayNode arr = mapper.createArrayNode();
arr.add("Java").add("JSON");
obj.set("tags", arr);

System.out.println(obj.toPrettyString());
/*
{
  "id" : 10,
  "name" : "Bob",
  "tags" : [ "Java", "JSON" ]
}
*/

3. Praca z Gson: JsonElement, JsonObject, JsonArray

Jackson to nie jedyny gracz. Gson również udostępnia wygodne API dla dynamicznego JSON: JsonElement, JsonObject, JsonArray.

Parsowanie do JsonElement

import com.google.gson.JsonElement;
import com.google.gson.JsonParser;

String json = "{\"id\":123,\"name\":\"Alice\",\"tags\":[\"java\",\"json\"]}";
JsonElement root = JsonParser.parseString(json);

Dostęp do pól

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

JsonObject obj = root.getAsJsonObject();
int id = obj.get("id").getAsInt();
String name = obj.get("name").getAsString();
JsonArray tags = obj.getAsJsonArray("tags");

for (JsonElement tag : tags) {
    System.out.println(tag.getAsString());
}

Zagnieżdżenie i bezpieczeństwo

if (obj.has("email")) {
    String email = obj.get("email").getAsString();
}

Praca z tablicami

String arrJson = "[{\"id\":1},{\"id\":2}]";
JsonArray arr = JsonParser.parseString(arrJson).getAsJsonArray();

for (JsonElement el : arr) {
    JsonObject item = el.getAsJsonObject();
    System.out.println(item.get("id").getAsInt());
}

Modyfikacja

W Gson obiekty są modyfikowalne — można dodawać i usuwać pola:

import com.google.gson.JsonObject;

JsonObject newObj = new JsonObject();
newObj.addProperty("id", 42);
newObj.add("tags", tags);
System.out.println(newObj.toString());

4. Praktyka: wydobywanie danych z nieznanego JSON

Zadanie: Załóżmy, że mamy konfigurację JSON, której struktura może się zmieniać:

{
  "service": "mail",
  "enabled": true,
  "params": {
    "host": "smtp.example.com",
    "port": 587
  }
}

Wyodrębnić host i port przy użyciu Jackson:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

ObjectMapper mapper = new ObjectMapper();
JsonNode root = mapper.readTree(json);
JsonNode params = root.path("params");
String host = params.path("host").asText();
int port = params.path("port").asInt();

System.out.println(host + ":" + port); // smtp.example.com:587

To samo w Gson:

import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

JsonObject rootObj = JsonParser.parseString(json).getAsJsonObject();
JsonObject params = rootObj.getAsJsonObject("params");
String host = params.get("host").getAsString();
int port = params.get("port").getAsInt();

System.out.println(host + ":" + port);

5. Typowe błędy i niuanse

Błąd nr 1: Błędne rzutowanie typów. Jeśli oczekujesz łańcucha znaków, a w polu jest liczba lub null, wywołanie asText() lub getAsString() da nieoczekiwany rezultat lub wyjątek. Na przykład, przy braku pola root.get("foo").asText() doprowadzi do NullPointerException.

Błąd nr 2: Brak sprawdzenia null. Zwłaszcza przy zagnieżdżonych odwołaniach: root.get("params").get("host"). Jeśli params nie istnieje — będzie NPE. W Jackson używaj path(), w Gson — sprawdzaj istnienie przez has oraz typ przez isJsonObject()/isJsonArray().

Błąd nr 3: Mieszanie typów węzłów. Jeśli pole jest tablicą, a odwołujesz się do niego jak do obiektu — pojawi się błąd. Sprawdzaj typy: Jackson — isArray()/isObject(), Gson — isJsonArray()/isJsonObject().

Błąd nr 4: Utrata informacji o typach podczas pracy z Map/List. Przy deserializacji do Map<String, Object> zagnieżdżone struktury stają się kaskadą Map/List, co utrudnia nawigację i prowadzi do wielu rzutowań typów oraz sprawdzeń instanceof.

Błąd nr 5: Niezrozumienie (nie)zmienności drzewa. W Jackson JsonNode jest niezmienny, a zmiany należy wykonywać przez ObjectNode i ArrayNode. W Gson obiekty są zmienialne; pamiętaj, że modyfikacja węzła dotyka wszystkich referencji do niego w bieżącym drzewie.

1
Zadanie
JAVA 25 SELF, poziom 46, lekcja 3
Niedostępne
Wyodrębnianie danych z profilu postaci gry 🎮
Wyodrębnianie danych z profilu postaci gry 🎮
1
Zadanie
JAVA 25 SELF, poziom 46, lekcja 3
Niedostępne
Przetwarzanie listy miast dla przewodnika 🗺️
Przetwarzanie listy miast dla przewodnika 🗺️
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION