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.
GO TO FULL VERSION