Java JSON mit Jackson | W3Docs Learn Java

Jackson ist die de-facto-Standardbibliothek für JSON in Java. Das JDK liefert keine eigene JSON-API, weshalb nahezu jede Spring-, Quarkus- oder Micronaut-Anwendung Jackson verwendet, um Java-Objekte in JSON-Text umzuwandeln und umgekehrt. Der Einstiegspunkt ist eine einzige zentrale Klasse — ObjectMapper — die die zwei Aufgaben übernimmt, die man immer benötigt: Serialisierung (Java-Objekt → JSON) und Deserialisierung (JSON → Java-Objekt).

Wenn Sie neu bei JSON in Java sind, beginnen Sie mit der JSON-Einführung. Für eine schlankere alternative Bibliothek lesen Sie das Gson-Kapitel. Diese Seite behandelt das Hinzufügen von Jackson, die drei Ebenen seiner API, Data Binding, das Baummodell und die Annotationen, die das Mapping steuern.

Jackson zum Projekt hinzufügen

Jackson ist nicht Bestandteil des JDK, daher deklarieren Sie es als Abhängigkeit. Das Artefakt jackson-databind bindet die beiden anderen Kernmodule (jackson-core und jackson-annotations) transitiv ein.

<!-- Maven -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.17.1</version>
</dependency>

// Gradle
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'

Die drei Wege, mit JSON zu arbeiten

Jackson stellt dieselben Daten auf drei verschiedene Arten bereit. Wählen Sie die Ebene, die zur Aufgabe passt:

Ansatz	Kerntyp	Verwenden, wenn
Data Binding	`ObjectMapper.readValue` / `writeValue`	Sie haben ein POJO oder Record, das den JSON widerspiegelt — der häufigste Fall
Baummodell	`JsonNode` über `readTree`	Die Struktur ist dynamisch oder Sie benötigen nur wenige Felder
Streaming	`JsonParser` / `JsonGenerator`	Sehr große Dokumente, die nicht vollständig im Speicher gehalten werden können

Data Binding verwenden Sie in 90 % der Fälle; die anderen beiden sind Ausweichmöglichkeiten.

Data Binding: Objekte rein, JSON raus

ObjectMapper.writeValueAsString serialisiert jedes Java-Objekt, indem es dessen Getter (oder Record-Komponenten) liest; readValue macht das Gegenteil und ordnet JSON-Feldnamen Ihren Feldern zu. Ein record ist das sauberste Ziel — Jackson 2.12+ bindet automatisch an seinen kanonischen Konstruktor, sodass Sie keine Getter oder einen No-Arg-Konstruktor schreiben müssen.

import com.fasterxml.jackson.databind.ObjectMapper;

record User(String name, int age, boolean active) {}

ObjectMapper mapper = new ObjectMapper();

// serialize: Java -> JSON
User ada = new User("Ada", 36, true);
String json = mapper.writeValueAsString(ada);
// {"name":"Ada","age":36,"active":true}

// deserialize: JSON -> Java
User back = mapper.readValue(json, User.class);
System.out.println(back.name()); // Ada

Für Collections und Generics übergeben Sie Jackson eine TypeReference, damit der Elementtyp die Typlöschung überlebt:

import com.fasterxml.jackson.core.type.TypeReference;

List<User> users = mapper.readValue(jsonArray, new TypeReference<List<User>>() {});

Das Baummodell: wenn die Struktur unbekannt ist

Wenn Sie keine passende Klasse haben (oder haben möchten), parsen Sie in einen generischen JsonNode-Baum und navigieren Sie ihn nach Schlüssel. Dies spiegelt wider, was ein manuell erstellter Map/List-Parser tut, aber mit typbewussten Accessoren wie asInt() und asText().

import com.fasterxml.jackson.databind.JsonNode;

JsonNode root = mapper.readTree(json);
String name = root.get("name").asText();
int age     = root.get("age").asInt();
JsonNode first = root.get("languages").get(0); // array access by index

Das Mapping mit Annotationen steuern

JSON-Feldnamen entsprechen selten perfekt den Java-Konventionen. Eine Handvoll Annotationen schließt die Lücke, ohne Ihre Feldnamen zu ändern:

Annotation	Wirkung
`@JsonProperty("user_name")`	Ein Feld auf einen anderen JSON-Schlüssel abbilden
`@JsonIgnore`	Ein Feld in beide Richtungen auslassen
`@JsonInclude(NON_NULL)`	`null`-Felder aus der Ausgabe weglassen
`@JsonCreator` / `@JsonFormat`	Benutzerdefinierte Konstruktion / Datumsformatierung

record Account(
    @JsonProperty("user_name") String userName,
    @JsonIgnore String passwordHash) {}

Ein vollständiges Beispiel: serialisieren, parsen und manuell binden

Jackson ist im Classpath dieses Runners nicht vorhanden, daher baut das folgende Programm dieselben Konzepte nach — einen JSON-Writer, einen rekursiv-absteigenden Parser in einen Map/List-Baum und das Binden in einen record — ausschließlich mit java.util. Das ist genau das, was ObjectMapper im Hintergrund für Sie tut: einen Objektgraphen durchlaufen, um Text zu erzeugen, und Text tokenisieren, um einen Baum neu aufzubauen.

java— editable, runs on the server

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

public class JacksonDemo {
  // A tiny JSON model: objects are Map<String,Object>, arrays are List<Object>.
  // Real code uses Jackson's ObjectMapper; here we model the same data binding by hand.

public static void main(String[] args) {
    // 1. SERIALIZE: build an object graph, then render it as JSON text.
    Map<String, Object> user = new LinkedHashMap<>();
    user.put("name", "Ada");
    user.put("age", 36);
    user.put("active", true);
    List<Object> langs = new ArrayList<>();
    langs.add("Java");
    langs.add("Ada");
    user.put("languages", langs);

String json = writeJson(user);
    System.out.println("serialized   : " + json);

// 2. PARSE: read JSON text back into the same Map/List tree (tree model).
    String input = "{\"name\":\"Grace\",\"age\":42,\"active\":false,\"languages\":[\"COBOL\",\"Java\"]}";
    Object tree = new Parser(input).parse();
    System.out.println("parsed type  : " + tree.getClass().getSimpleName());

// 3. NAVIGATE the tree, the way ObjectMapper.readTree() + JsonNode.get() do.
    @SuppressWarnings("unchecked")
    Map<String, Object> parsed = (Map<String, Object>) tree;
    System.out.println("name field   : " + parsed.get("name"));
    System.out.println("age field    : " + parsed.get("age") + " (" + parsed.get("age").getClass().getSimpleName() + ")");

// 4. BIND into a typed record, the way ObjectMapper.readValue(json, User.class) does.
    @SuppressWarnings("unchecked")
    List<Object> plist = (List<Object>) parsed.get("languages");
    List<String> typed = new ArrayList<>();
    for (Object o : plist) typed.add((String) o);
    User bound = new User((String) parsed.get("name"), (int) parsed.get("age"), typed);
    System.out.println("bound record : " + bound);

// 5. ROUND-TRIP: re-serialize the parsed tree and confirm it survives.
    System.out.println("round-trip   : " + writeJson(parsed));
  }

record User(String name, int age, List<String> languages) {}

// ---- minimal JSON writer ----
  static String writeJson(Object value) {
    StringBuilder sb = new StringBuilder();
    write(value, sb);
    return sb.toString();
  }

@SuppressWarnings("unchecked")
  static void write(Object value, StringBuilder sb) {
    if (value == null) { sb.append("null"); return; }
    if (value instanceof String s) { sb.append('"').append(s).append('"'); return; }
    if (value instanceof Boolean || value instanceof Number) { sb.append(value); return; }
    if (value instanceof Map<?, ?> m) {
      sb.append('{');
      boolean first = true;
      for (Map.Entry<?, ?> e : m.entrySet()) {
        if (!first) sb.append(',');
        first = false;
        sb.append('"').append(e.getKey()).append("\":");
        write(e.getValue(), sb);
      }
      sb.append('}');
      return;
    }
    if (value instanceof List<?> list) {
      sb.append('[');
      for (int i = 0; i < list.size(); i++) {
        if (i > 0) sb.append(',');
        write(list.get(i), sb);
      }
      sb.append(']');
      return;
    }
    throw new IllegalArgumentException("unsupported: " + value.getClass());
  }

// ---- minimal recursive-descent JSON parser ----
  static class Parser {
    private final String s;
    private int i = 0;
    Parser(String s) { this.s = s; }

Object parse() { skip(); return value(); }

private Object value() {
      skip();
      char c = s.charAt(i);
      return switch (c) {
        case '{' -> object();
        case '[' -> array();
        case '"' -> string();
        case 't', 'f' -> bool();
        case 'n' -> nul();
        default -> number();
      };
    }

private Map<String, Object> object() {
      Map<String, Object> m = new LinkedHashMap<>();
      i++; // {
      skip();
      if (s.charAt(i) == '}') { i++; return m; }
      while (true) {
        skip();
        String key = string();
        skip();
        i++; // :
        m.put(key, value());
        skip();
        char c = s.charAt(i++);
        if (c == '}') break;
      }
      return m;
    }

private List<Object> array() {
      List<Object> list = new ArrayList<>();
      i++; // [
      skip();
      if (s.charAt(i) == ']') { i++; return list; }
      while (true) {
        list.add(value());
        skip();
        char c = s.charAt(i++);
        if (c == ']') break;
      }
      return list;
    }

private String string() {
      StringBuilder sb = new StringBuilder();
      i++; // opening quote
      while (s.charAt(i) != '"') sb.append(s.charAt(i++));
      i++; // closing quote
      return sb.toString();
    }

private Object number() {
      int start = i;
      while (i < s.length() && "-+.eE0123456789".indexOf(s.charAt(i)) >= 0) i++;
      String num = s.substring(start, i);
      if (num.contains(".") || num.contains("e") || num.contains("E"))
        return Double.parseDouble(num);
      return Integer.parseInt(num);
    }

private Boolean bool() {
      if (s.charAt(i) == 't') { i += 4; return Boolean.TRUE; }
      i += 5; return Boolean.FALSE;
    }

private Object nul() { i += 4; return null; }

private void skip() { while (i < s.length() && Character.isWhitespace(s.charAt(i))) i++; }
  }
}

Was man aus der Ausführung mitnimmt:

Serialisierung durchläuft einen Objektgraphen und erzeugt Text. Die serialized-Zeile zeigt eine verschachtelte Map/List, die zu {"name":"Ada",...,"languages":["Java","Ada"]} gerendert wird — ein Array innerhalb eines Objekts. ObjectMapper.writeValueAsString führt denselben rekursiven Durchlauf über die Getter Ihres POJOs oder die Komponenten eines Records durch.
Das Parsen baut zuerst einen generischen Baum auf. Der Laufzeittyp des geparsten Werts ist LinkedHashMap, nicht User — genau das Baummodell von Jackson, bei dem readTree einen JsonNode zurückgibt, den Sie nach Schlüssel navigieren, bevor eine Klasse beteiligt ist.
JSON-Zahlen werden zu Java-Zahlen, mit einer Typentscheidung. Das Feld age kam als Integer (42) zurück, weil der Text keinen Dezimalpunkt hatte; der Parser wählte Integer statt Double. Jackson trifft dieselbe Entscheidung, weshalb ein int-Feld sauber gebunden wird, während 3.14 als Double ankäme.
Der Feldzugriff erfolgt nach Name, und die Reihenfolge wird beibehalten. Die Verwendung von LinkedHashMap bewahrte die Schlüssel in Einfügereihenfolge, sodass name vor age gelesen wird. Jackson bewahrt die Schlüsselreihenfolge von Objekten auf dieselbe Weise, weshalb ein round-tripped JSON wie das Original aussieht.
Round-Tripping ist verlustfrei, wenn das Modell übereinstimmt. Die letzte Zeile re-serialisierte den geparsten Baum zum selben JSON, aus dem er stammte, und der typisierte User-Record band name, age und languages korrekt — der eigentliche Zweck von Data Binding: Text rein, Objekt raus, Text zurück, kein Datenverlust.

Übungen

Übung

Mit Jackson erhalten Sie eine JSON-Antwort, deren Struktur Sie nicht kontrollieren, und Sie müssen nur zwei Felder aus einem großen, tief verschachtelten Dokument lesen. Welcher Ansatz passt am besten?

Es in einen 'JsonNode'-Baum mit 'ObjectMapper.readTree' parsen und die zwei Felder mit 'get(...)' abrufenEine vollständige Java-Klasse erstellen, die jedes Feld im Dokument widerspiegelt, und 'readValue' für Data Binding verwendenDie rohen JSON-Zeichenketten verketten und die Werte mit 'String.substring' extrahierenEinen 'DatagramSocket' verwenden, um den JSON zu streamen und die Felder direkt auszulesen