Zum Inhalt springen

Java JSON Parser: die Simple JSON API in Java 28 (JEP 540)

Vor Koralle liegt links eine gerade Kette aus sechs bunten Glasperlen auf einem gedrehten Messingdraht. Rechts steigt der Draht auf und verzweigt sich zu einem kleinen Baum, an dessen acht Astspitzen Perlen in denselben Farben sitzen und warmweiß leuchten

Wer in Java JSON lesen oder schreiben wollte, brauchte bisher eine Bibliothek wie Jackson oder Gson. Mit Java 28 kommt ein JSON-Parser ins JDK: die Simple JSON API, zunächst als Incubator-Modul jdk.incubator.json.

Die API ist klein. Ein Interface für JSON-Werte, sechs Subtypen, eine Klasse zum Parsen und Ausgeben – das ist alles. Für einzelne Werte aus einer REST-Antwort, einer Konfigurationsdatei oder einem Thread-Dump reicht das, ohne Dependency und ohne Konfiguration.

In diesem Artikel erfährst du:

  • Was die Simple JSON API ist und wie du sie heute schon ausprobieren kannst
  • Wie du JSON parst, durch das Dokument navigierst und Werte in Java-Typen umwandelst
  • Wie du Werte liest, die mal fehlen, mal null sind oder je nach Version einen anderen Typ haben
  • Wie du die Fehlermeldungen liest – samt Pfad zur betroffenen Stelle
  • Wie du JSON erzeugst und änderst
  • Wie du mit der API einen JSON-Thread-Dump auswertest
  • Was die API nicht kann und wann du besser zu Jackson oder Gson greifst

Alle Beispielprogramme findest du im GitHub-Repository java-json-api.

Was ist die Simple JSON API?

Die Simple JSON API ist eine JSON-API im JDK, definiert durch JDK Enhancement Proposal 540. Sie parst und erzeugt JSON nach RFC 8259, dem aktuellen JSON-Standard. JEP 540 löst JEP 198 ab, einen ersten Anlauf für eine JSON-API aus dem Jahr 2014.

Das Ziel ist, einfache Aufgaben mit wenig Code zu erledigen: ein paar Werte aus einem Dokument lesen, ein kleines Dokument erzeugen. Die etablierten Bibliotheken zu ersetzen, ist ausdrücklich kein Ziel. Deshalb fehlt alles, was Jackson und Gson darüber hinaus können:

  • Data Binding: JSON direkt in Java-Objekte umwandeln und zurück
  • Streaming: ein Dokument Stück für Stück lesen, ohne es ganz im Speicher zu halten
  • Syntaxerweiterungen: Kommentare, Kommas nach dem letzten Element, einfache Anführungszeichen
  • Konfiguration: verschiedene Parser-Einstellungen

Wie das im Code aussieht, zeige ich an einem kleinen Dokument, das sich durch den ganzen Artikel zieht. Es beschreibt Java 28 mit drei seiner JEPs und liegt im Repository als release.json:

{
  "version": 28,
  "ga": "2027-03-09",
  "lts": false,
  "jeps": [
    { "number": 401, "title": "Value Objects", "preview": true },
    { "number": 540, "title": "Simple JSON API", "incubator": true },
    { "number": 543, "title": "Structured Concurrency" }
  ],
  "successor": { "version": 29, "ga": null }
}

Das Dokument enthält alle sechs Arten von JSON-Werten: Zahlen, Strings, Booleans, null, Objekte und ein Array. Und Java 29 hat am 15. November 2026 noch keinen festen GA-Termin – daher das null.

Das folgende Programm liest die Datei, holt die Version, das GA-Datum und den Titel des ersten JEPs heraus und gibt sie aus:

import jdk.incubator.json.*;

void main() throws IOException {
  JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

  int version = release.get("version").asInt();
  String ga = release.get("ga").asString();
  String firstJep = release.get("jeps").get(0).get("title").asString();

  IO.println("Java " + version + " (GA " + ga + "), first JEP: " + firstJep);
}

Drei Schritte, mehr braucht es nicht: Json.parse() parst den Text, get() navigiert zum gewünschten Wert, und asInt() bzw. asString() wandelt ihn in einen Java-Typ um. Das Programm ist ein Compact Source File mit Instance Main Method – Files, Path und IO sind dort ohne Import verfügbar. Die Ausgabe:

WARNING: Using incubator modules: jdk.incubator.json
Java 28 (GA 2027-03-09), first JEP: Value Objects

Die erste Zeile gibt die JVM bei jedem Start aus, solange die API ein Incubator-Modul ist. In den weiteren Ausgaben in diesem Artikel lasse ich sie weg.

Die Simple JSON API ausprobieren

Ein Incubator-Modul enthält eine API, die noch nicht final ist. Die JDK-Entwickler:innen sammeln damit Rückmeldungen, bevor sie die API festschreiben – bis dahin kann sie sich noch ändern.

Incubator-Module heißen immer jdk.incubator.* und sind im JDK enthalten, aber standardmäßig nicht aktiv. Von einem Preview-Feature unterscheidet sich ein Incubator-Modul dadurch, dass es eine reine Bibliothek ist: Sprache und JVM bleiben unverändert, deshalb brauchst du kein --enable-preview, sondern fügst das Modul mit --add-modules hinzu.

Du brauchst einen Early-Access-Build von Java 28 von jdk.java.net/28. Alle Ausgaben in diesem Artikel stammen von Build 28-ea+23.

Mit dem Source Launcher startest du ein Programm direkt aus der .java-Datei:

java --add-modules jdk.incubator.json QuickStart.java

Kompilierst du mit javac, brauchst du die Option beim Kompilieren und beim Starten:

javac --add-modules jdk.incubator.json QuickStart.java
java --add-modules jdk.incubator.json QuickStart

javac warnt dabei mit warning: [incubating] using incubating module(s): jdk.incubator.json. Fehlt die Option, bricht javac mit dem Fehler package jdk.incubator.json is not visible ab.

Zum Ausprobieren eignet sich auch die JShell:

$ jshell --add-modules jdk.incubator.json
jshell> import jdk.incubator.json.*
jshell> var release = Json.parse(Files.readString(Path.of("release.json")))
release ==> {"version":28,"ga":"2027-03-09","lts":false,"jeps ... :{"version":29,"ga":null}}
jshell> release.get("jeps").get(1).get("title").asString()
$3 ==> "Simple JSON API"

JSON parsen mit Json.parse()

Die Klasse Json hat zwei Methoden zum Parsen: Json.parse(String) und Json.parse(char[]). Ein Array kopiert parse() vorher, sodass spätere Änderungen daran das Ergebnis nicht beeinflussen.

Ein Reader, ein InputStream oder ein Path als Eingabe ist nicht vorgesehen. Die API geht davon aus, dass das Dokument und der daraus erzeugte Baum in den Speicher passen. Eine Datei liest du daher zuerst mit Files.readString() ein. Nutzt du den HttpClient des JDK, lässt du dir eine HTTP-Antwort mit HttpResponse.BodyHandlers.ofString() als String geben; bei anderen HTTP-Clients liest du den Body ebenfalls zuerst als String.

Der Parser ist strikt: Er akzeptiert nur JSON nach RFC 8259 und lehnt Kommentare, Kommas nach dem letzten Element und doppelte Namen in einem Objekt ab. Wie die Fehlermeldungen bei einem Verstoß gegen diese Regeln aussehen, steht im Abschnitt Fehlermeldungen lesen.

Ein Baum aus JsonValue-Objekten

Json.parse() liefert die Wurzel eines Baums aus JsonValue-Objekten. JsonValue ist ein sealed Interface mit genau sechs Subtypen – einem für jede Art von JSON-Wert: String, Zahl, Boolean, null, Objekt und Array. Die folgende Grafik zeigt die sechs Subtypen und unter jedem Namen einen Wert dieses Typs aus release.json; {…} und […] stehen für ein Objekt und ein Array mit beliebigem Inhalt:

Oben ein Kasten „sealed interface JsonValue“, darunter über eine gemeinsame Vererbungslinie sechs Kästen: JsonString mit "2027-03-09", JsonNumber mit 28, JsonBoolean mit false, JsonNull mit null, JsonObject mit {…} und JsonArray mit […]
Jeder JSON-Wert ist genau einer der sechs Subtypen von JsonValue

Alle JsonValue-Objekte sind unveränderlich und threadsicher.

Weil JsonValue sealed ist, kann ein switch mit Type Patterns alle Subtypen abdecken, ohne default-Zweig.

Die Name-Value-Paare eines Objekts, z. B. "version": 28, heißen in RFC 8259 Member. Das folgende Programm gibt für jeden Member des Wurzelobjekts dessen Typ und eine Beschreibung des Werts aus:

import jdk.incubator.json.*;

void main() throws IOException {
  JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

  for (var member : release.asMap().entrySet()) {
    IO.println(member.getKey() + ": " + describe(member.getValue()));
  }
}

String describe(JsonValue value) {
  return switch (value) {
    case JsonObject object -> "object with " + object.asMap().size() + " members";
    case JsonArray array -> "array with " + array.asList().size() + " elements";
    case JsonString string -> "string " + string.asString();
    case JsonNumber number -> "number " + number.asInt();
    case JsonBoolean bool -> "boolean " + bool.asBoolean();
    case JsonNull _ -> "null";
  };
}

JsonValue.asMap() liefert die Member eines Objekts als Map – mehr dazu im Abschnitt JSON-Werte in Java-Werte umwandeln. Im letzten case steht ein unbenanntes Pattern, denn ein JsonNull hat keinen Wert, den das Programm bräuchte. Die Ausgabe:

version: number 28
ga: string 2027-03-09
lts: boolean false
jeps: array with 3 elements
successor: object with 2 members

Beachte die Reihenfolge: Ein geparstes JsonObject behält die Member in der Reihenfolge, in der sie im Dokument stehen.

Durch ein JSON-Dokument navigieren

Die beiden Methoden zum Navigieren, JsonValue.get(String) (für Objekte) und JsonValue.get(int) (für Arrays), sind bereits im Interface JsonValue deklariert. Du musst einen Wert also nicht nach JsonObject oder JsonArray casten, bevor du darauf zugreifst, sondern kannst die Aufrufe direkt verketten:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

IO.println(release.get("jeps").get(2).get("title").asString());
IO.println(release.get("successor").get("version").asInt());

Die erste Zeile holt aus dem Wurzelobjekt das Array jeps, daraus das dritte Element und davon den Member title. Die zweite Zeile liest die Version aus dem verschachtelten Objekt successor. Die Ausgabe:

Structured Concurrency
29

Die Grafik zeigt den Baum, den Json.parse() aus release.json baut, von der Wurzel links bis zu den Blättern rechts. Jeder Kasten nennt den Member mit seinem Wert und darunter den Subtyp; die Elemente 0 und 1 des Arrays jeps sind zugeklappt. Blau hervorgehoben ist der Weg der ersten Zeile, release.get("jeps").get(2).get("title"):

Baumdiagramm: Links das Wurzelobjekt, daraus Pfeile zu den Membern "version": 28, "ga": "2027-03-09", "lts": false, "jeps" (ein JsonArray) und "successor" (ein JsonObject). Von "jeps" führen Pfeile zu den Elementen 0, 1 und 2, von Element 2 zu "number": 543 und "title": "Structured Concurrency", von "successor" zu "version": 29 und "ga": null. Der Weg von der Wurzel über "jeps" und Element 2 zu "title" ist blau hervorgehoben
Jeder get()-Aufruf geht eine Ebene tiefer: von der Wurzel über jeps und das Element 2 zum Member title

Fehlt ein Member, liegt ein Index außerhalb des Arrays oder hat ein Wert nicht den erwarteten Typ, wirft get() eine JsonValueException – z. B. bei get(0) auf dem Objekt successor, das kein Array ist. Wie du damit umgehst, zeige ich im Abschnitt Fehlende Member, null und wechselnde Typen.

Über Arrays und Objekte iterieren

Über die Elemente eines Arrays kannst du mit asList() iterieren, über die Member eines Objekts mit asMap(). Das folgende Listing gibt alle JEPs einmal mit einer Schleife und einmal als Liste ihrer Nummern aus und danach die Member von successor:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

for (JsonValue jep : release.get("jeps").asList()) {
  IO.println("JEP " + jep.get("number").asInt() + ": " + jep.get("title").asString());
}

List<Integer> numbers = release.get("jeps").asList().stream()
    .map(jep -> jep.get("number").asInt())
    .toList();
IO.println(numbers);

release.get("successor").asMap()
    .forEach((name, value) -> IO.println(name + " = " + value));

asList() liefert eine gewöhnliche List<JsonValue>, auf der du auch Streams aufbauen kannst. Die Ausgabe:

JEP 401: Value Objects
JEP 540: Simple JSON API
JEP 543: Structured Concurrency
[401, 540, 543]
version = 29
ga = null

In der letzten Zeile siehst du, wie die Methode toString() ein JsonNull ausgibt: als null im JSON-Format.

JSON-Werte in Java-Werte umwandeln

Die Umwandlungsmethoden as…(), die einen JSON-Wert in einen Java-Wert umwandeln – z. B. eine JSON-Zahl in einen int –, sind wie die Navigationsmethoden im Interface JsonValue deklariert. Jede funktioniert aber nur für einen Subtyp – für alle anderen wirft sie eine JsonValueException. Die Tabelle zeigt die sieben Methoden:

MethodeSubtypJava-Typ
asString()JsonStringString
asInt()JsonNumberint
asLong()JsonNumberlong
asDouble()JsonNumberdouble
asBoolean()JsonBooleanboolean
asMap()JsonObjectMap<String, JsonValue>
asList()JsonArrayList<JsonValue>

Für JsonNull gibt es keine Umwandlungsmethode – dafür ist tryValue() da, das ich im Abschnitt Fehlende Member, null und wechselnde Typen zeige.

Jede Methode liest nur ihren eigenen JSON-Typ: Eine JSON-Zahl kannst du als int, long oder double lesen, einen JSON-String aber nicht als Zahl. asInt() auf einem String wie "28" versucht also nicht, den String als Zahl zu parsen, sondern wirft eine JsonValueException. Umgekehrt ist es genauso: asString() auf der Zahl 28 liefert nicht den Text „28“, sondern wirft ebenfalls eine JsonValueException. Brauchst du eine Zahl als Text, rufst du toString() auf.

Die Map aus asMap() und die List aus asList() sind unveränderlich.

Eine Falle steckt in den Namen asString() und toString(). Das folgende Programm ruft beide auf dem GA-Datum auf:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));
JsonValue ga = release.get("ga");

IO.println(ga.asString());
IO.println(ga.toString());
IO.println(ga);

Die Ausgabe:

2027-03-09
"2027-03-09"
"2027-03-09"

asString() liefert den Inhalt des Strings. toString() liefert dagegen den JSON-Text des Werts, also mit Anführungszeichen – und genau das gibt auch IO.println(ga) aus. Wer einen JsonString in einen Text einbaut, ohne asString() aufzurufen, bekommt die Anführungszeichen mit.

Die übrigen Umwandlungsmethoden zeigt das nächste Programm. Es liest lts als boolean, die Version als long und als double und das Objekt successor als Map:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

IO.println(release.get("lts").asBoolean());
IO.println(release.get("version").asLong());
IO.println(release.get("version").asDouble());

Map<String, JsonValue> successor = release.get("successor").asMap();
IO.println(successor.keySet());

Die Ausgabe:

false
28
28.0
[version, ga]

Zahlen umwandeln

Eine JSON-Zahl kann beliebig groß und beliebig genau sein; ein int, ein long und ein double können das nicht. Die API löst das so:

  • asInt() und asLong() wandeln nur Zahlen um, die sich exakt darstellen lassen. Eine Zahl mit Nachkommastellen ist erlaubt, wenn sie ganzzahlig ist: 123.0 und 234.56E2 gehen, 345.6 nicht. Eine Zahl außerhalb des Wertebereichs führt zu einer Exception statt zu einem Überlauf.
  • asDouble() rundet auf das nächste double. Eine Zahl außerhalb des Wertebereichs von double führt ebenfalls zu einer Exception. Double.parseDouble() würde für eine solche Zahl stattdessen Infinity liefern, für eine negative -Infinity.

Das folgende Programm probiert das an einigen Zahlen aus. Die Hilfsmethode tryToConvert() gibt das Ergebnis einer Umwandlung aus oder – falls sie scheitert – die Meldung der JsonValueException:

void main() {
  IO.println(Json.parse("123.0").asInt());
  IO.println(Json.parse("234.56E2").asInt());
  tryToConvert(() -> Json.parse("345.6").asInt());
  tryToConvert(() -> Json.parse("2147483648").asInt());
  IO.println(Json.parse("2147483648").asLong());

  IO.println(Json.parse("3.141592653589793238462643383279").asDouble());
  tryToConvert(() -> Json.parse("1.8E309").asDouble());

  JsonValue price = Json.parse("19.990");
  IO.println(price);
  IO.println(new BigDecimal(price.toString()));
}

void tryToConvert(Supplier<Object> conversion) {
  try {
    IO.println(conversion.get());
  } catch (JsonValueException e) {
    IO.println(e.getMessage());
  }
}

Json.parse() akzeptiert übrigens jeden JSON-Wert als Dokument, nicht nur Objekte und Arrays – also auch eine einzelne Zahl. Die Ausgabe:

123
23456
345.6 cannot be represented as an int. Path: "". Location: line 0, position 0.
2147483648 cannot be represented as an int. Path: "". Location: line 0, position 0.
2147483648
3.141592653589793
1.8E309 cannot be represented as a double. Path: "". Location: line 0, position 0.
19.990
19.990

2147483648 ist um eins größer als Integer.MAX_VALUE und passt daher nicht in ein int, wohl aber in ein long. Pi mit 30 Nachkommastellen rundet asDouble() auf das nächste double, 3.141592653589793.

Die letzten beiden Zeilen zeigen den Weg ohne Verlust: Bei einer geparsten Zahl liefert toString() den Text genau so, wie er im Dokument stand – mit der Null am Ende. Daraus erzeugst du ein BigDecimal oder ein BigInteger. Eine Methode asBigDecimal() gibt es bewusst nicht: JEP 540 hält die Zahl der Umwandlungsmethoden klein, weil new BigDecimal(value.toString()) fast genauso kurz ist.

Fehlende Member, null und wechselnde Typen

JSON-Dokumente haben kein Schema, und ein Dokument ändert sich mit der Zeit. Ein Member fehlt in manchen Objekten, ein Wert ist mal ein String und mal null, oder ein Wert wechselt mit einer neuen Version des Formats seinen Typ. Mit get() und den as…()-Methoden bekommst du in allen drei Fällen eine JsonValueException. Für jeden der drei Fälle hat die API eine Lösung.

Optionale Member: tryGet()

Ein Member, der fehlen darf, liest du mit JsonValue.tryGet(String). Die Methode liefert ein Optional, das den Wert des Members als JsonValue enthält, oder ein leeres Optional, wenn es den Member nicht gibt. Im Beispieldokument trägt nur der JEP 401 den Member "preview": true. Das folgende Listing hängt den Zusatz „(Preview)“ deshalb nur dort an:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

for (JsonValue jep : release.get("jeps").asList()) {
  boolean preview = jep.tryGet("preview").map(JsonValue::asBoolean).orElse(false);
  IO.println(jep.get("title").asString() + (preview ? " (Preview)" : ""));
}

Die Ausgabe:

Value Objects (Preview)
Simple JSON API
Structured Concurrency

tryGet() gibt es nur mit einem Namen als Parameter, nicht mit einem Index, denn die Methode liest optionale Member von Objekten. Rufst du sie auf einem Wert auf, der kein Objekt ist, z. B. auf dem Array jeps, wirft sie wie get(String) eine JsonValueException. Leer ist das Optional also nur, wenn der Member fehlt – nicht, wenn die Struktur nicht stimmt.

null-Werte: tryValue()

Das GA-Datum von Java 29 steht im Beispieldokument als null. Für solche Werte gibt es JsonValue.tryValue(): Die Methode liefert ein leeres Optional, wenn der JsonValue, auf dem du sie aufrufst, ein JsonNull ist, und sonst ein Optional mit genau diesem JsonValue. Das folgende Listing gibt statt null den Text „not set“ aus:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));
JsonValue successor = release.get("successor");
String ga = successor.get("ga").tryValue().map(JsonValue::asString).orElse("not set");
IO.println("Java " + successor.get("version").asInt() + ", GA: " + ga);

Die Ausgabe:

Java 29, GA: not set

Ein Unterschied zwischen den beiden Methoden ist leicht zu übersehen: tryGet() liefert für einen Member, dessen Wert null ist, kein leeres Optional, sondern eines mit einem JsonNull darin. Willst du ein leeres Optional sowohl für einen fehlenden Member als auch für einen null-Wert, verkettest du beide Methoden mit flatMap():

JsonValue successor = release.get("successor");
IO.println(successor.tryGet("ga"));
IO.println(successor.tryGet("rampdown"));
IO.println(successor.tryGet("ga").flatMap(JsonValue::tryValue));

Das Objekt successor enthält den Member ga mit dem Wert null, einen Member rampdown gibt es nicht. Die Ausgabe:

Optional[null]
Optional.empty
Optional.empty

Die Tabelle fasst zusammen, welcher Aufruf in welchem Fall was liefert. „Wert“ steht dabei für den Wert des Members als JsonValue:

AufrufMember vorhandenMember nullMember fehlt
get("ga")WertJsonNullException
tryGet("ga")Optional mit WertOptional mit JsonNullleeres Optional
get("ga").tryValue()Optional mit Wertleeres OptionalException
tryGet("ga")
.flatMap(JsonValue::tryValue)
Optional mit Wertleeres Optionalleeres Optional

Wechselnde Typen: switch mit Type Patterns

Manchmal ändert sich nicht, ob ein Wert da ist, sondern welchen Typ er hat. Ein Beispiel aus dem JDK selbst: In JSON-Thread-Dumps steht die ID eines Threads (tid) bis Java 26 als String, seit Java 27 als Zahl. Ein Programm, das Dumps beider Versionen lesen soll, unterscheidet die Fälle mit einem switch:

long threadId(JsonValue thread) {
  return switch (thread.get("tid")) {
    case JsonNumber number -> number.asLong();
    case JsonString string -> Long.parseLong(string.asString());
    default -> throw new JsonValueException("Unexpected type for \"tid\"");
  };
}

Hier ist ein default-Zweig nötig, obwohl JsonValue sealed ist, denn der switch deckt nur zwei der sechs Subtypen ab. Ohne default kommt ein switch nur aus, wenn er alle sechs abdeckt – wie im Programm im Abschnitt Ein Baum aus JsonValue-Objekten. Der Konstruktor von JsonValueException ist öffentlich, sodass auch eigener Code diese Exception werfen kann. Das ganze Programm steht im Repository als ChangingTypes.java. Die Methode threadId() setze ich weiter unten im Praxisbeispiel ein.

Fehlermeldungen lesen

Die JSON-API wirft zwei Exceptions, beide unchecked: eine JsonParseException, wenn der Text kein gültiges JSON ist, und eine JsonValueException, wenn du auf einen Wert zugreifst, den es nicht gibt oder der einen anderen Typ hat. Beide Meldungen enthalten einen Pfad und die Stelle im Dokument.

Ungültiges JSON: JsonParseException

Das folgende Programm parst vier Dokumente, die gegen RFC 8259 verstoßen: ein Komma nach dem letzten Member, einen doppelten Namen, einfache Anführungszeichen und einen Kommentar. Die Methode tryToParse() gibt jeweils die Meldung und die Stelle aus, die die Exception mit getErrorLine() und getErrorPosition() liefert:

void main() {
  tryToParse("""
      { "version": 28, }""");
  tryToParse("""
      { "version": 28, "version": 29 }""");
  tryToParse("""
      { 'version': 28 }""");
  tryToParse("""
      {
        // Java 28
        "version": 28
      }""");
}

void tryToParse(String json) {
  try {
    Json.parse(json);
  } catch (JsonParseException e) {
    IO.println(e.getMessage());
    IO.println("  line " + e.getErrorLine() + ", position " + e.getErrorPosition());
  }
}

Die Ausgabe:

Expecting a JSON Object member name. Path: "{". Location: line 0, position 17.
  line 0, position 17
Duplicate member name: "version" was already parsed. Path: "{". Location: line 0, position 17.
  line 0, position 17
Expecting a JSON Object member name. Path: "{". Location: line 0, position 2.
  line 0, position 2
Expecting a JSON Object member name. Path: "{". Location: line 1, position 2.
  line 1, position 2

Zeile und Position zählen ab 0. line 1, position 2 im letzten Beispiel ist also die zweite Zeile und dort das dritte Zeichen – der erste Schrägstrich des Kommentars. Im ersten Beispiel zeigt Position 17 auf die geschweifte Klammer, an der der Parser den nächsten Namen erwartet hat.

Dass doppelte Namen ein Fehler sind, ist eine bewusste Entscheidung. RFC 8259 sagt nur, die Namen in einem Objekt sollten eindeutig sein, und viele Bibliotheken übernehmen bei doppelten Namen still den letzten Wert. JEP 540 begründet die Strenge damit, dass zwei Systeme mit verschiedenen Bibliotheken dasselbe Dokument sonst unterschiedlich lesen könnten – eine Quelle schwer zu findender Fehler und von Sicherheitslücken. Wie eine solche Lücke entsteht, zeigt die folgende Infobox.

Für Kommentare empfiehlt JEP 540, sie vor dem Parsen zu entfernen. Stehen sie wie im Beispiel oben in eigenen Zeilen, die mit // beginnen, reicht ein regulärer Ausdruck:

String text = Files.readString(Path.of("config.json"));
JsonValue config = Json.parse(text.replaceAll("(?m)^\\s*//.*$", ""));

Falscher Zugriff: JsonValueException

Das folgende Programm greift auf fünf Arten falsch auf release.json zu: auf einen Member, der fehlt, auf einen Index außerhalb des Arrays, mit dem falschen Typ, mit get(String) auf ein Array und mit asString() auf null. Die Hilfsmethode tryToRead() ist wie tryToConvert() aus dem Abschnitt Zahlen umwandeln aufgebaut und gibt die Meldung der Exception aus:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

tryToRead(() -> release.get("jeps").get(2).get("preview"));
tryToRead(() -> release.get("jeps").get(3));
tryToRead(() -> release.get("version").asString());
tryToRead(() -> release.get("jeps").get("title"));
tryToRead(() -> release.get("successor").get("ga").asString());

Die Ausgabe:

JsonObject member "preview" does not exist. Path: "{jeps[2". Location: line 7, position 4.
JsonArray index 3 out of bounds for length 3. Path: "{jeps". Location: line 4, position 10.
JsonNumber is not a JsonString. Path: "{version". Location: line 1, position 13.
JsonArray is not a JsonObject. Path: "{jeps". Location: line 4, position 10.
JsonNull is not a JsonString. Path: "{successor{ga". Location: line 9, position 38.

Der Pfad führt von der Wurzel zu dem Wert, auf dem der fehlgeschlagene Aufruf lief. Die API notiert ihn in einer eigenen Kurzform:

  • { steht für ein Objekt, gefolgt vom Namen des Members.
  • [ steht für ein Array, gefolgt vom Index.

Geschlossen werden die Klammern nicht. {jeps[2 bedeutet also: Member jeps des Wurzelobjekts, darin das Element mit dem Index 2 (also das dritte Element). In diesem Objekt fehlt der Member preview. line 7, position 4 zeigt auf die öffnende Klammer dieses Objekts – die achte Zeile von release.json, das fünfte Zeichen.

Bei verketteten Aufrufen findest du so sofort heraus, welches Glied der Kette gescheitert ist, ohne den Ausdruck zu zerlegen.

JSON erzeugen

Zum Erzeugen von JSON hat jeder Subtyp eine statische Factory-Methode of():

  • JsonString.of(String) escapt Anführungszeichen, Backslashes und Steuerzeichen.
  • JsonNumber.of() gibt es für int, long, double und String. Die String-Variante wandelt Text in eine Zahl um – also genau das, was die as…()-Methoden bei einem JSON-String verweigern. Sie prüft den Text gegen die JSON-Grammatik, lehnt z. B. "028" oder "abc" mit einer IllegalArgumentException ab und übernimmt ihn sonst unverändert: Aus "-0.5e3" wird nicht -500.0, und auch "1.8E309" außerhalb des double-Bereichs ist erlaubt. NaN und Infinity lehnt die double-Variante mit einer IllegalArgumentException ab, denn JSON kennt sie nicht.
  • JsonBoolean.of(boolean)
  • JsonNull.of()
  • JsonArray.of(List<? extends JsonValue>)
  • JsonObject.of(Map<String, ? extends JsonValue>)

Die beiden letzten erwarten JsonValue-Objekte. Du musst also jeden Wert selbst verpacken – eine 28 statt JsonNumber.of(28) kompiliert nicht.

JsonObject.of() übernimmt die Reihenfolge der übergebenen Map. Die Iterationsreihenfolge von Map.of() ist allerdings nicht festgelegt, wie das folgende Listing zeigt:

JsonObject release = JsonObject.of(Map.of(
    "version", JsonNumber.of(28),
    "ga", JsonString.of("2027-03-09")));
IO.println(release);

Bei sechs Starts desselben Programms stand viermal version vorn und zweimal ga:

{"version":28,"ga":"2027-03-09"}
{"ga":"2027-03-09","version":28}

Brauchst du eine feste Reihenfolge, übergib eine LinkedHashMap.

Das folgende Programm erzeugt aus einer Liste von Jep-Records ein JSON-Objekt mit der Java-Version und den JEPs. Dieses Objekt und die Objekte der einzelnen JEPs baut es jeweils aus einer LinkedHashMap, damit die Member in einer festen Reihenfolge stehen. Die Methode toJson() wandelt einen Jep-Record in ein JsonObject um:

record Jep(int number, String title) {}

void main() {
  List<Jep> jeps = List.of(
      new Jep(401, "Value Objects"),
      new Jep(540, "Simple JSON API"),
      new Jep(543, "Structured Concurrency"));

  var members = new LinkedHashMap<String, JsonValue>();
  members.put("version", JsonNumber.of(28));
  members.put("jeps", JsonArray.of(jeps.stream().map(this::toJson).toList()));
  JsonObject release = JsonObject.of(members);

  IO.println(release);
  IO.println(Json.toDisplayString(release, "  "));
}

JsonObject toJson(Jep jep) {
  var members = new LinkedHashMap<String, JsonValue>();
  members.put("number", JsonNumber.of(jep.number()));
  members.put("title", JsonString.of(jep.title()));
  return JsonObject.of(members);
}

Das Programm gibt das Objekt zweimal aus. In der ersten Zeile mit toString() – kompakt, ohne Leerzeichen und Zeilenumbrüche, geeignet zum Speichern und Übertragen. Darunter mit Json.toDisplayString() – eingerückt und damit gut lesbar; das zweite Argument ist die Einrückung pro Ebene. Die Ausgabe:

{"version":28,"jeps":[{"number":401,"title":"Value Objects"},{"number":540,"title":"Simple JSON API"},{"number":543,"title":"Structured Concurrency"}]}
{
  "version": 28,
  "jeps": [
    {
      "number": 401,
      "title": "Value Objects"
    },
    {
      "number": 540,
      "title": "Simple JSON API"
    },
    {
      "number": 543,
      "title": "Structured Concurrency"
    }
  ]
}

Die Einrückung darf nur aus Leerzeichen, Tabs und Zeilenumbrüchen bestehen, sonst wirft toDisplayString() eine IllegalArgumentException. Beide Ausgaben kann Json.parse() wieder einlesen.

JSON-Werte ändern

Ein JsonValue ist unveränderlich. Willst du einen Wert ändern, musst du die Member in eine neue Map kopieren, sie dort ändern und daraus ein neues Objekt bauen. Das folgende Listing entfernt aus release.json die JEPs und ergänzt den Feature Freeze von Java 28:

JsonValue release = Json.parse(Files.readString(Path.of("release.json")));

var members = new LinkedHashMap<>(release.asMap());
members.remove("jeps");
members.put("featureFreeze", JsonString.of("2026-12-03"));
IO.println(JsonObject.of(members));

Die Ausgabe:

{"version":28,"ga":"2027-03-09","lts":false,"successor":{"version":29,"ga":null},"featureFreeze":"2026-12-03"}

JSON-Werte vergleichen

Das folgende Listing parst zweimal dasselbe Objekt und vergleicht die beiden Ergebnisse, einmal mit equals() und einmal über den Java-Wert des Members version:

JsonValue a = Json.parse("{ \"version\": 28 }");
JsonValue b = Json.parse("{ \"version\": 28 }");
IO.println(a.equals(b));
IO.println(a.get("version").asInt() == b.get("version").asInt());

Die Ausgabe:

false
true

Zwei gleiche Objekte sind laut equals() nicht gleich. Das ist kein Fehler, sondern Absicht: Laut Javadoc definiert JsonValue weder Identitäts- noch Wertsemantik. Die Implementierungsklassen erben equals() von Object und vergleichen deshalb Referenzen. Den Grund hat Naoto Sato, der Autor der Implementierung, im Code-Review genannt: Die Entwickler haben Gleichheit bewusst nicht definiert, damit sich niemand versehentlich auf ein bestimmtes Verhalten verlässt. Wer zwei Werte vergleichen will, wandelt sie in Java-Werte um und vergleicht diese.

Ein Vergleich über toString() funktioniert, solange es dir reicht, dass zwei Dokumente bis auf Leerzeichen und Zeilenumbrüche übereinstimmen. Verschiedene Schreibweisen desselben Werts gelten dabei nicht als gleich, denn ein geparster Wert behält seinen Text: 1 und 1.0 ergeben verschiedene Strings, ebenso "\u0041" und "A" oder zwei Objekte mit denselben Membern in anderer Reihenfolge.

Praxisbeispiel: einen Thread-Dump auswerten

Ein JSON-Dokument, das jede:r Java-Entwickler:in sofort zur Hand hat, liefert das JDK selbst: jcmd erzeugt einen Thread-Dump mit virtuellen Threads auch im JSON-Format.

Das Kommando dafür:

jcmd <pid> Thread.dump_to_file -format=json <file>

Für das Beispiel habe ich unter Java 26, 27 und 28 Thread-Dumps des Programms Waiter aus dem Repository zu diesem Artikel erstellt. Waiter hält einen Thread aus einem Thread-Pool in wait() fest und lässt einen virtuellen Thread und den Main-Thread schlafen. Der Anfang des Dumps von Java 28:

{
  "threadDump": {
    "formatVersion": 2,
    "processId": 52046,
    "time": "2026-11-14T11:37:48.232193Z",
    "runtimeVersion": "28-ea+23-1886",
    "threadContainers": [
      {
        "container": "<root>",
        "parent": null,
        "owner": null,
        "threads": [
          {
            "tid": 3,
            "time": "2026-11-14T11:37:48.234120Z",
            "name": "main",
            "state": "TIMED_WAITING",
            "stack": [
              ...

Das Dokument bringt alle drei Fälle aus dem Abschnitt Fehlende Member, null und wechselnde Typen mit: Der Member waitingOn steht nur bei Threads, die auf ein Objekt warten, parent ist beim Wurzel-Container null, und tid ist bis Java 26 ein String.

Das folgende Programm gibt für jeden Container mit Threads dessen Namen und Eltern-Container aus, darunter jeden Thread mit ID, Namen, Zustand und gegebenenfalls dem Objekt, auf das er wartet. Am Ende zählt es die Threads pro Zustand:

import jdk.incubator.json.*;

void main(String[] args) throws IOException {
  JsonValue dump = Json.parse(Files.readString(Path.of(args[0]))).get("threadDump");
  IO.println("Runtime " + dump.get("runtimeVersion").asString());

  Map<String, Integer> threadsPerState = new TreeMap<>();

  for (JsonValue container : dump.get("threadContainers").asList()) {
    List<JsonValue> threads = container.get("threads").asList();
    if (threads.isEmpty()) continue;

    String name = container.get("container").asString();
    String parent = container.get("parent").tryValue()
        .map(JsonValue::asString).orElse("none");
    IO.println(name + " (parent: " + parent + ")");

    for (JsonValue thread : threads) {
      String state = thread.get("state").asString();
      String waitingOn = thread.tryGet("waitingOn")
          .map(lock -> ", waiting on " + lock.asString()).orElse("");
      IO.println("  #" + threadId(thread) + " " + thread.get("name").asString()
          + ": " + state + waitingOn);
      threadsPerState.merge(state, 1, Integer::sum);
    }
  }

  IO.println(threadsPerState);
}

long threadId(JsonValue thread) {
  return switch (thread.get("tid")) {
    case JsonNumber number -> number.asLong();
    case JsonString string -> Long.parseLong(string.asString());
    default -> throw new JsonValueException("Unexpected type for \"tid\"");
  };
}

Du siehst hier alle drei Werkzeuge im Einsatz: tryValue() für den Eltern-Container, tryGet() für waitingOn und die Methode threadId() mit dem switch aus dem Abschnitt Wechselnde Typen. Die Ausgabe für den Dump von Java 28:

Runtime 28-ea+23-1886
<root> (parent: none)
  #3 main: TIMED_WAITING
  #14 Reference Handler: RUNNABLE
  #15 Finalizer: WAITING, waiting on java.lang.Object@149b987a
  #16 Signal Dispatcher: RUNNABLE
  #31 Notification Thread: RUNNABLE
  #32 Common-Cleaner: TIMED_WAITING, waiting on java.lang.Object@16d3f6dc
  #40 VirtualThread-unblocker: RUNNABLE
  #44 Attach Listener: RUNNABLE
  #41 sleeper: TIMED_WAITING
java.util.concurrent.ThreadPoolExecutor@2805c96b (parent: <root>)
  #39 pool-1-thread-1: WAITING, waiting on java.lang.Object@57b5a6c9
ForkJoinPool-1/jdk.internal.vm.SharedThreadContainer@a997c51 (parent: <root>)
  #42 ForkJoinPool-1-worker-1: TIMED_WAITING
  #43 ForkJoinPool-1-delayScheduler: TIMED_WAITING
{RUNNABLE=5, TIMED_WAITING=5, WAITING=2}

Drei der Threads gehören zu Waiter: main und der virtuelle Thread sleeper, beide im Zustand TIMED_WAITING, sowie pool-1-thread-1 im Container seines Thread-Pools, wartend auf das Objekt, auf dem er wait() aufgerufen hat. Alle anderen Threads hat die JVM selbst gestartet.

Dasselbe Programm liest ohne Änderung auch den Dump von Java 26, in dem tid ein String ist. Die ersten Zeilen der Ausgabe:

Runtime 26.0.1+8-34
<root> (parent: none)
  #3 main: TIMED_WAITING
  #16 Reference Handler: RUNNABLE
  #17 Finalizer: WAITING, waiting on java.lang.ref.ReferenceQueue$Lock@4442c626

Übrigens hat Java 27 neben tid noch zwei weitere Stellen des Formats geändert, die das Programm nicht liest: processId ist seitdem eine Zahl statt eines Strings, und der Member formatVersion ist neu – im Dump von Java 26 fehlt er noch. Liest dein Programm diese Member, muss es also auch bei ihnen mit beiden Typen bzw. mit einem fehlenden Member umgehen.

Grenzen der Simple JSON API

Was die API nicht kann, folgt aus ihrem Ziel – einfache Aufgaben mit wenig Code:

  • Kein Data Binding: Records und Klassen musst du selbst aus den Werten zusammenbauen bzw. selbst in JsonValue-Objekte verpacken.
  • Kein Streaming: Das ganze Dokument muss als String oder char[] im Speicher liegen, dazu der Baum, den Json.parse() daraus baut. Für ein Dokument mit mehreren Gigabyte ist die API nicht gedacht.
  • Keine Syntaxerweiterungen: Kommentare, Kommas nach dem letzten Element und einfache Anführungszeichen führen immer zu einer JsonParseException. Abschalten lässt sich das nicht.
  • Kein equals(): Selbst für zwei inhaltlich gleiche JSON-Werte liefert equals() false. Du musst JSON-Werte daher über ihre Java-Werte vergleichen.

Dazu kommt der Status: Als Incubator-Modul braucht die API --add-modules, die JVM gibt bei jedem Start eine Warnung aus, und die API kann sich bis zur finalen Fassung noch ändern. Laut JEP 540 sammeln die JDK-Entwickler:innen in der Incubator-Phase u. a. Anwendungsfälle für das Erzeugen und Umbauen von JSON, um diesen Teil der API weiterzuentwickeln.

Vergleich mit Jackson und Gson

Wie viel Code spart die Simple JSON API gegenüber den beiden verbreitetsten Bibliotheken, Jackson und Gson? Ich habe dieselbe Aufgabe mit allen drei gelöst: aus release.json alle JEPs mit Nummer und Titel ausgeben und den Zusatz „(Preview)“ anhängen, wenn "preview": true gesetzt ist. Verglichen habe ich mit Jackson 3.3.0 und Gson 2.15.0.

Mit der Simple JSON API:

String json = Files.readString(Path.of("release.json"));
JsonValue release = Json.parse(json);

for (JsonValue jep : release.get("jeps").asList()) {
  boolean preview = jep.tryGet("preview").map(JsonValue::asBoolean).orElse(false);
  IO.println(jep.get("number").asInt() + " " + jep.get("title").asString()
      + (preview ? " (Preview)" : ""));
}

Mit Jackson:

String json = Files.readString(Path.of("release.json"));
JsonNode release = new ObjectMapper().readTree(json);

for (JsonNode jep : release.get("jeps")) {
  boolean preview = jep.path("preview").asBoolean(false);
  IO.println(jep.get("number").asInt() + " " + jep.get("title").asString()
      + (preview ? " (Preview)" : ""));
}

Mit Gson:

String json = Files.readString(Path.of("release.json"));
JsonObject release = JsonParser.parseString(json).getAsJsonObject();

for (JsonElement element : release.getAsJsonArray("jeps")) {
  JsonObject jep = element.getAsJsonObject();
  boolean preview = jep.has("preview") && jep.get("preview").getAsBoolean();
  IO.println(jep.get("number").getAsInt() + " " + jep.get("title").getAsString()
      + (preview ? " (Preview)" : ""));
}

Alle drei Programme geben dasselbe aus:

401 Value Objects (Preview)
540 Simple JSON API
543 Structured Concurrency

Die Programme sind fast gleich lang. Jackson liest den optionalen Member mit path(), das für einen fehlenden Member einen Platzhalter-Knoten liefert, und asBoolean(false). Gson unterscheidet zwischen JsonElement und JsonObject, sodass du jedes Element erst mit getAsJsonObject() umwandeln musst. Die Simple JSON API braucht keinen Cast und keinen Platzhalter, sondern ein Optional.

Ein Unterschied zeigt sich nicht im Code, sondern in den Dependencies: Jackson bringt drei JARs mit zusammen 2,7 MB mit, Gson zwei JARs mit 0,3 MB. Die Simple JSON API kostet keine Dependency.

Data Binding mit Jackson und Gson

Was Jackson und Gson können und die Simple JSON API nicht, zeigt das folgende Programm mit Jackson. Es wandelt release.json mit einem einzigen Aufruf in verschachtelte Records um:

record Jep(int number, String title, boolean preview, boolean incubator) {}
record Successor(int version, String ga) {}
record Release(int version, String ga, boolean lts, List<Jep> jeps,
               Successor successor) {}

void main() throws IOException {
  Release release = new ObjectMapper()
      .readValue(Files.readString(Path.of("release.json")), Release.class);

  IO.println(release.version() + ", GA " + release.ga());
  release.jeps().forEach(IO::println);
  IO.println(release.successor());
}

Die Ausgabe:

28, GA 2027-03-09
Jep[number=401, title=Value Objects, preview=true, incubator=false]
Jep[number=540, title=Simple JSON API, preview=false, incubator=true]
Jep[number=543, title=Structured Concurrency, preview=false, incubator=false]
Successor[version=29, ga=null]

Fehlende Booleans setzt Jackson auf false, null übernimmt es als null. Mit Gson steht an der Stelle von new ObjectMapper().readValue(…) der Aufruf new Gson().fromJson(…), die Ausgabe ist dieselbe. Mit der Simple JSON API bräuchtest du für dasselbe Ergebnis eine Methode pro Record, die die Werte einzeln ausliest.

Unterschiede im Detail

Deutlich unterscheiden sich die drei APIs beim Umgang mit Dokumenten, die nicht dem Erwarteten entsprechen. Das Programm EdgeCases im Repository liest aus sechs Dokumenten jeweils den Member version mit asInt() bzw. getAsInt():

  1. { "version": 28, "version": 29 } – ein doppelter Name
  2. ein Objekt mit dem Member "version": 28 und davor der Kommentarzeile // Java 28
  3. { "version": 345.6 } – eine Zahl mit Nachkommastellen
  4. { "version": "28" } – eine Zahl als String
  5. { "version": 2147483648 } – eine Zahl jenseits von Integer.MAX_VALUE
  6. { } – ein Objekt ohne den Member

Die Tabelle zeigt das Ergebnis oder den Namen der Exception:

FallSimple JSON APIJacksonGson
doppelter NameJsonParseException2929
KommentarJsonParseExceptionStreamReadException28
NachkommastellenJsonValueException345345
Zahl als StringJsonValueException2828
int-ÜberlaufJsonValueExceptionJsonNodeException−2147483648
Member fehltJsonValueExceptionNullPointerExceptionNullPointerException

Jackson und Gson sind teils nachsichtig, teils ungenau und teils schlicht falsch. Nachsichtig sind sie, wenn sie bei doppelten Namen still den letzten Wert übernehmen und einen String als Zahl lesen; Gson akzeptiert in JsonParser.parseString() sogar Kommentare. Ungenau sind beide bei Nachkommastellen: Sie schneiden sie ab und machen aus 345.6 die Zahl 345. Schlicht falsch ist das Ergebnis von Gson beim Überlauf: Aus 2147483648 wird −2147483648. Ein fehlender Member führt bei beiden zu null und damit zur NullPointerException beim nächsten Aufruf.

Die Simple JSON API wirft in allen sechs Fällen eine Exception, und deren Meldung nennt den Pfad zur betroffenen Stelle. Jackson und Gson lassen sich strenger konfigurieren – die Simple JSON API ist von Haus aus streng.

Wann was?

Ich empfehle dir die Simple JSON API für Skripte, Kommandozeilen-Werkzeuge und Programme, die aus einem JSON-Dokument ein paar Werte lesen oder ein kleines Dokument erzeugen. Dort sparst du die Dependency, und die strenge Prüfung meldet ein unerwartetes Dokument mit einer Exception statt mit einem falschen Wert.

Zu Jackson oder Gson greifst du, wenn du Data Binding brauchst oder Dokumente streamen musst. Jackson ist außerdem die naheliegende Wahl, wenn du ohnehin in einem Framework arbeitest, das es mitbringt – wie Spring Boot.

Für Produktionscode solltest du warten, bis die API final ist. Bis dahin kann sich jeder Aufruf in diesem Artikel noch ändern.

Fazit

  • Die Simple JSON API aus JEP 540 ist in Java 28 ein Incubator-Modul. Du aktivierst sie mit --add-modules jdk.incubator.json.
  • Json.parse() parst einen String oder ein char[] in einen Baum aus JsonValue-Objekten. JsonValue ist ein sealed Interface mit sechs Subtypen, die du mit einem switch ohne default abdecken kannst.
  • get() navigiert ohne Casts durch Objekte und Arrays, die as…()-Methoden wandeln Werte in Java-Typen um – nur exakt und nur, wenn der Subtyp passt. asInt() auf 345.6 wirft eine Exception, statt 345 zu liefern.
  • tryGet() liefert ein leeres Optional, wenn ein Member fehlt, tryValue(), wenn ein Wert null ist; sonst enthält das Optional den JsonValue. Für einen Member mit dem Wert null liefert tryGet() also kein leeres Optional, sondern eines mit einem JsonNull. Leer in beiden Fällen ist erst tryGet(name).flatMap(JsonValue::tryValue).
  • Fehlermeldungen nennen den Pfad zum Wert und die Stelle im Dokument, Zeile und Position ab 0 gezählt.
  • Erzeugt wird JSON mit den of()-Methoden der Subtypen; toString() gibt es kompakt aus, Json.toDisplayString() eingerückt. Für eine feste Reihenfolge der Member übergibst du eine LinkedHashMap.
  • Gegenüber Jackson und Gson fehlen Data Binding, Streaming und jede Konfiguration. Dafür braucht die API keine Dependency und lehnt doppelte Namen und verlustbehaftete Umwandlungen ab, die beide Bibliotheken stillschweigend hinnehmen, ebenso Kommentare, die Gson akzeptiert.

Ich empfehle dir, die Simple JSON API jetzt mit dem Early-Access-Build auszuprobieren – z. B. am nächsten Skript, für das du sonst Jackson eingebunden hättest. Im Projektcode solltest du sie erst einsetzen, wenn sie final ist.

War dieser Artikel hilfreich für dich? Dann freue ich mich, wenn du dir kurz Zeit für eine Bewertung auf meinem ProvenExpert-Profil nimmst.

👉 Bewertung abgeben

Dieses Thema im eigenen Code?

Du hast den Artikel gelesen – im Training arbeitet ihr damit. 2 Tage lang gehen wir die Themen an euren eigenen Projekten durch, statt an konstruierten Beispielen.

Praxisnah, verständlich und direkt auf euren Projektalltag übertragbar. Statt Theorie vermittle ich Prinzipien, die euch helfen, Code langfristig besser, wartbarer und performanter zu schreiben.

Java 25 SchulungAlle Trainings ansehen

Werde ein:e bessere:r Java-Entwickler:in

Mit meinem kostenlosen Newsletter bleibst du vorn. Modernes Java: neue Versionen & Features, Performance und JVM-Insights – 1x im Monat.

Suche