Im Internet hat JSON das XML-Format zwecks Objekt\u00fcbertragung zwischen Server und Browser fast vollst\u00e4ndig verdr\u00e4ngt. Das liegt daran, dass ein Browser JSON-Strings direkt in JavaScript-Objekte konvertieren kann, XML-Dokumente aber erst aufw\u00e4ndiger verarbeitet werden m\u00fcssen.<\/p>\n
Neben dem Einsatzgebiet im Internet bietet JSON auch ein kompaktes Format, um etwa lokale Konfigurationsdateien zu kodieren.<\/p>\n
Nehmen wir folgende Zeile JavaScript-Code, die ein Person-Objekt mit zwei Properties f\u00fcr Name und Alter definiert. Eine Property wird \u00fcber ein Schl\u00fcssel-Wert-Paar beschrieben:<\/p>\n
var person = { „name“ : „Michael Jackson“, „age“ : 50 };<\/p>\n
Die Definition eines Objekts geschieht in der JSON (JavaScript Object Notation). Als Datentypen unterst\u00fctzt JSON Zahlen, Wahrheitswerte, Strings, Arrays, null und Objekte \u2013 wie unser Beispiel zeigt. Die Deklarationen k\u00f6nnen geschachtelt sein, um Unterobjekte aufzubauen.<\/p>\n
Zum Zugriff auf die JSON-Daten kommt der Punkt zum Einsatz, sodass der Name nach der Auswertung durch person.name zug\u00e4nglich ist.<\/p>\n
Eine Personenbeschreibung wie diese kann in einem String stehen, der von JavaScript zur Laufzeit ausgewertet wird.<\/p>\n
var json = ‚person = { „name“ : „Michael Jackson“, „age“ : 50 };‘;<\/p>\n
Der Zugriff auf person.name liefert wie vorher den Namen, denn nach der Auswertung mit eval(\u2026) wird JavaScript ein neues Objekt mit person im Kontext anlegen.<\/p>\n
JSON ist besonders praktisch, wenn es darum geht, Daten zwischen einem Server und einem Browser mit JavaScript-Interpreter auszutauschen. Denn wenn der String json nicht von Hand mit einem String initialisiert wurde, sondern ein Server die Zeichenkette person = { … }; liefert, haben wir das, was heutzutage in modernen Ajax-Webanwendungen passiert.<\/p>\n
Die letzte Frage ist nun, wie elegant der Server Zeichenketten im Datenaustauschformat JSON erzeugt und so Objekte \u00fcbertr\u00e4gt. Den String per Hand aufzubauen ist eine L\u00f6sung, aber es geht besser.<\/p>\n
Zum Verarbeiten von JSON-Dokumenten gibt es in der Java SE keine Standardklassen, sodass sich eine Reihe von Open-Source-Bibliotheken herausgepr\u00e4gt haben; Jackson\u00a0(http:\/\/tutego.de\/go\/jackson) geh\u00f6rt zu den popul\u00e4rsten L\u00f6sungen. 2013 wurde dann die JSR 353, \u00bbJava API for JSON Processing\u00ab, verabschiedet, die Teil der Jakarta EE 7 ist, 2014 dann das JSR 374 \u00bbJava API for JSON Processing 1.1\u00ab.<\/p>\n
Wir k\u00f6nnen die JSON-API in unseren Java SE-Programmen nutzen, m\u00fcssen daf\u00fcr aber Java-Archive im Klassenpfad einbinden. Die Referenzimplementierung befindet sich unter https:\/\/javaee.github.io\/jsonp\/. Am einfachsten haben es Maven-Nutzer, sie binden in ihre POM die Abh\u00e4ngigkeiten auf den \u201eDefault provider for JSR 374:Java API for Processing JSON\u201c ein:<\/p>\n
<dependency>
\n<groupId>org.glassfish<\/groupId>
\n<artifactId>javax.json<\/artifactId>
\n<version>1.1<\/version>
\n<\/dependency><\/p>\n
Die Implementierung hat eine Abh\u00e4ngigkeit zur JSON-API javax.json:javax.json-api, die wir dann nicht unbedingt selbst in die POM mit aufnehmen m\u00fcssen.<\/p>\n
Der Typ JsonObject ist in der API zentral, denn er definiert ein hierarchisches Model mit den Schl\u00fcssel-Wert-Paaren eines JSON-Objekts. Um ein JsonObject aufzubauen, k\u00f6nnen wir \u00fcber den JsonObjectBuilder gehen, oder wir lassen den Parser JsonReader aus einer String-Repr\u00e4sentation ein JsonObject erzeugen. Zum formatierten Schreiben in einen Ausgabestrom k\u00f6nnen wir einen einfachen JsonWriter von der Json-Klasse holen \u2013 es geht aber noch einfacher \u00fcber toString() \u2013 oder \u00fcber die JsonWriterFactory arbeiten, falls wir eine h\u00fcbsche einger\u00fcckte Ausgabe w\u00fcnschen. Ein Beispiel:<\/p>\n
Point p = new Point( 10, 20 );<\/p>\n
JsonObjectBuilder objBuilder = Json.createObjectBuilder()
\n.add( „x“, p.x )
\n.add( „y“, p.y );
\nJsonObject jsonObj = objBuilder.build();<\/p>\n
System.out.println( jsonObj );\u00a0 \/\/ {„x“:10,“y“:20}<\/p>\n
Json.createWriter( System.out ).write( jsonObj ); \/\/ {„x“:10,“y“:20}<\/p>\n
Map<String, Boolean> config = new HashMap<>();
\nconfig.put( JsonGenerator.PRETTY_PRINTING, true );
\nJsonWriterFactory writerFactory = Json.createWriterFactory( config );<\/p>\n
StringWriter out = new StringWriter();
\nwriterFactory.createWriter( out ).write( jsonObj );
\nSystem.out.println( out );\u00a0 \/\/ {\\n\u00a0\u00a0\u00a0 „x“: 10, …<\/p>\n
JsonReader reader = Json.createReader( new StringReader( out.toString() ) );
\nSystem.out.println( reader.readObject().getInt( „x“ ) ); \/\/ 10<\/p>\n
Soll der assoziierte Wert ein Array sein, so wird das Array mit Json.createArrayBuilder().add(..).add(..) aufgebaut und gef\u00fcllt.<\/p>\n
So wie es f\u00fcr XML eine Pull-API gibt, existiert sie auch f\u00fcr JSON-Dokumente; das ist von Vorteil, wenn die Daten sehr umfangreich sind. Ein Beispiel zeigt das sehr gut:<\/p>\n
URL url = new URL( „https:\/\/data.cityofnewyork.us\/api\/views\/25th-nujf\/rows.json?accessType=DOWNLOAD“ );<\/p>\n
try ( JsonParser parser = Json.createParser( url.openStream() ) ) {
\nwhile ( parser.hasNext() ) {
\nswitch ( parser.next() ) {
\ncase KEY_NAME:
\ncase VALUE_STRING:
\nSystem.out.println( parser.getString() );
\nbreak;
\ncase VALUE_NUMBER:
\nSystem.out.println( parser.getBigDecimal() );
\nbreak;
\ncase VALUE_TRUE:
\nSystem.out.println( true );
\nbreak;
\ncase VALUE_FALSE:
\nSystem.out.println( false );
\nbreak;
\ncase VALUE_NULL:
\ncase START_ARRAY:
\ncase END_ARRAY:
\ncase START_OBJECT:
\ncase END_OBJECT:
\n\/\/ Ignore
\n}
\n}
\n}<\/p>\n
Zum Schreiben gibt es Vergleichbares, einen JsonGenerator; die API ist selbsterkl\u00e4rend:<\/p>\n
JsonGenerator gen = Json.createGenerator( System.out );
\ngen.writeStartArray();
\ngen.writeStartObject();
\ngen.write( „x“, „12“ );
\ngen.write( „y“, „2“ );
\ngen.writeEnd();
\ngen.writeStartObject()
\n.write( „x“, „99“ )
\n.write( „x“, „123“ )
\n.writeEnd();
\ngen.writeEnd().close();
\n\/\/ [{„x“:“12″,“y“:“2″},{„x“:“99″,“x“:“123″}]<\/p>\n
Der JsonGenerator ist AutoCloseable, sodass er gut in einem try-mit-Ressoucen-Block eingesetzt werden kann.<\/p>\n
Das JSR 353 beschreibt kein automatisches Objekt-JSON-Mapping, wie JAXB das Objekt-XML-Mapping erm\u00f6glicht. Das wird im Standard JSR 367, \u00bbJava API for JSON Binding (JSON-B)\u00ab definiert. Die Website http:\/\/json-b.net\/ liefert Hintergrundinformationen, die Referenzimplementierung ist Eclipse Yasson.<\/p>\n
Um das mit einem Beispiel testen zu k\u00f6nnen, nehmen wie Yasson in unsere POM mit auf:<\/p>\n
<dependency><\/p>\n
<groupId>org.eclipse<\/groupId><\/p>\n
<artifactId>yasson<\/artifactId><\/p>\n
<version>1.0.1<\/version><\/p>\n
<\/dependency><\/p>\n
Die Dependency selbst hat eine Maven Abh\u00e4ngigkeit auf javax.json.bind:javax.json.bind-api, also der eigentliche API.<\/p>\n
Zur Abbildung bauen wir uns ein Beispielobjekt und bringen es in das JSON-Format. Im zweiten Schritt \u00fcbertragen wir den JSON-String wieder auf das Objekt:<\/p>\n
public class JsonbDemo {<\/p>\n
public static class EvilLaboratory {<\/p>\n
public String from;<\/p>\n
public double volume;<\/p>\n
public boolean didPayElectricityBill;<\/p>\n
public List<String> items;<\/p>\n
}<\/p>\n
public static void main( String[] args ) {<\/p>\n
EvilLaboratory lab1 = new EvilLaboratory();<\/p>\n
lab1.from = „Frank“;<\/p>\n
lab1.didPayElectricityBill = true;<\/p>\n
lab1.volume = 12442.33;<\/p>\n
lab1.items = List.of( „corpses“, „animals“ );<\/p>\n
<\/p>\n
Jsonb jsonbuilder = JsonbBuilder.create();<\/p>\n
String jsonString = jsonbuilder.toJson( lab1 );<\/p>\n
System.out.println( jsonString );<\/p>\n
<\/p>\n
EvilLaboratory lab2 = jsonbuilder.fromJson( jsonString, EvilLaboratory.class );<\/p>\n
System.out.printf( „from=%s, volume=%s, didPayElectricityBill=%s, items=%s“,<\/p>\n
lab2.from, lab2.volume, lab2.didPayElectricityBill, lab2.items );<\/p>\n
}<\/p>\n
}<\/p>\n","protected":false},"excerpt":{"rendered":"
Im Internet hat JSON das XML-Format zwecks Objekt\u00fcbertragung zwischen Server und Browser fast vollst\u00e4ndig verdr\u00e4ngt. Das liegt daran, dass ein Browser JSON-Strings direkt in JavaScript-Objekte konvertieren kann, XML-Dokumente aber erst aufw\u00e4ndiger verarbeitet werden m\u00fcssen. Neben dem Einsatzgebiet im Internet bietet JSON auch ein kompaktes Format, um etwa lokale Konfigurationsdateien zu kodieren. JSON im Kontext von […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[11],"tags":[],"class_list":["post-4195","post","type-post","status-publish","format-standard","hentry","category-insel"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4195","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=4195"}],"version-history":[{"count":1,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4195\/revisions"}],"predecessor-version":[{"id":4196,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4195\/revisions\/4196"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=4195"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=4195"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=4195"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}