Einführung in JSON-Java (org.json)

1. Einführung in JSON-Java

JSON (Abkürzung für JavaScript Object Notation) ist ein leichtes Datenaustauschformat und wird am häufigsten für die Client-Server-Kommunikation verwendet. Es ist sowohl leicht zu lesen / schreiben als auch sprachunabhängig. Ein JSON-Wert kann ein anderes JSON- Objekt, Array, eine andere Zahl, eine andere Zeichenfolge, ein Boolescher Wert (true / false) oder null sein.

In diesem Tutorial erfahren Sie, wie Sie JSON mithilfe einer der verfügbaren JSON-Verarbeitungsbibliotheken erstellen, bearbeiten und analysieren können. Die JSON-Java-Bibliothek wird auch als org.json bezeichnet.

2. Voraussetzung

Bevor wir beginnen, müssen wir die folgende Abhängigkeit in unsere pom.xml einfügen :

 org.json json 20180130 

Die neueste Version finden Sie im Maven Central-Repository.

Beachten Sie, dass dieses Paket bereits im Android SDK enthalten ist. Wir sollten es daher nicht einschließen, wenn Sie dasselbe verwenden.

3. JSON in Java [Paket org.json]

Die JSON-Java-Bibliothek ist auch als org.json bekannt (nicht zu verwechseln mit der org.json.simple von Google) und bietet Klassen, mit denen JSON in Java analysiert und bearbeitet werden kann.

Darüber hinaus kann diese Bibliothek auch zwischen JSON, XML, HTTP-Headern, Cookies, durch Kommas getrennten Listen oder Text usw. konvertieren.

In diesem Tutorial sehen wir uns Folgendes an:

  1. JSONObject - ähnlich dem nativen Map- ähnlichen Objektvon Java, indem ungeordnete Schlüssel-Wert-Paare gespeichert sind
  2. JSONArray - eine geordnete Folge von Werten, die der nativen Vector-Implementierung von Java ähnelt
  3. JSONTokener - ein Tool, das einen Text in eine Reihe von Token aufteilt , die von JSONObject oder JSONArray zum Parsen von JSON-Zeichenfolgen verwendet werden können
  4. CDL - ein Tool, das Methoden zum Konvertieren von durch Kommas getrenntem Text in ein JSONArray und umgekehrt bereitstellt
  5. Cookie - Konvertiert von JSON String in Cookies und umgekehrt
  6. HTTP - wird zum Konvertieren von JSON- Zeichenfolgen in HTTP-Header und umgekehrt verwendet
  7. JSONException - Dies ist eine Standardausnahme, die von dieser Bibliothek ausgelöst wird

4. JSONObject

Ein JSONObject ist eine ungeordnete Sammlung von Schlüssel- und Wertepaaren, die den nativen Map- Implementierungen von Java ähnelt .

  • Schlüssel sind eindeutige Zeichenfolgen , die nicht null sein dürfen
  • Werte können beliebig sein, von einem Booleschen Wert , einer Zahl , einem String , einem JSONArray oder sogar einem JSONObject.NULL- Objekt
  • Ein JSONObject kann durch einen String in geschweiften Klammern dargestellt werden, wobei Schlüssel und Werte durch einen Doppelpunkt und Paare durch ein Komma getrennt sind
  • Es verfügt über mehrere Konstruktoren, mit denen ein JSONObject erstellt werden kann

Es werden auch die folgenden Hauptmethoden unterstützt:

  1. get (String key) - Ruft das dem angegebenen Schlüssel zugeordnete Objekt ab und löst eine JSONException aus, wenn der Schlüssel nicht gefunden wird
  2. opt (String key) - Legt das dem angegebenen Schlüssel zugeordnete Objekt fest, andernfalls null
  3. put (String key, Object value) - fügt ein Schlüssel-Wert-Paar in das aktuelle JSONObject ein oder ersetzt es .

Die put () -Methode ist eine überladene Methode, die einen Schlüssel vom Typ String und mehrere Typen für den Wert akzeptiert .

Die vollständige Liste der von JSONObject unterstützten Methoden finden Sie in der offiziellen Dokumentation.

Lassen Sie uns nun einige der Hauptoperationen diskutieren, die von dieser Klasse unterstützt werden.

4.1. JSON direkt aus JSONObject erstellen

JSONObject stellt eine API bereit, die der Map- Oberfläche von Java ähnelt . Wir können die put () -Methode verwenden und den Schlüssel und den Wert als Argument angeben:

JSONObject jo = new JSONObject(); jo.put("name", "jon doe"); jo.put("age", "22"); jo.put("city", "chicago");

Jetzt würde unser JSONObject so aussehen:

{"city":"chicago","name":"jon doe","age":"22"}

Es gibt sieben verschiedene überladene Signaturen der JSONObject.put () -Methode. Während der Schlüssel nur eine eindeutige Zeichenfolge ungleich Null sein kann , kann der Wert beliebig sein.

4.2. JSON aus Map erstellen

Anstatt Schlüssel und Werte direkt in ein JSONObject einzufügen , können wir eine benutzerdefinierte Map erstellen und diese dann als Argument an den Konstruktor von JSONObject übergeben .

Dieses Beispiel führt zu denselben Ergebnissen wie oben:

Map map = new HashMap(); map.put("name", "jon doe"); map.put("age", "22"); map.put("city", "chicago"); JSONObject jo = new JSONObject(map);

4.3. Erstellen JSONObject von JSON String

Um einen JSON- String in ein JSONObject zu analysieren , können wir den String einfach an den Konstruktor übergeben.

Dieses Beispiel führt zu denselben Ergebnissen wie oben:

JSONObject jo = new JSONObject( "{\"city\":\"chicago\",\"name\":\"jon doe\",\"age\":\"22\"}" );

Das übergebene String- Argument muss ein gültiger JSON sein, sonst kann dieser Konstruktor eine JSONException auslösen .

4.4. Serialisieren Sie das Java-Objekt in JSON

Einer der Konstruktoren von JSONObject verwendet ein POJO als Argument. Im folgenden Beispiel verwendet das Paket die Getter aus der DemoBean- Klasse und erstellt dafür ein entsprechendes JSONObject .

To get a JSONObject from a Java Object, we'll have to use a class that is a valid Java Bean:

DemoBean demo = new DemoBean(); demo.setId(1); demo.setName("lorem ipsum"); demo.setActive(true); JSONObject jo = new JSONObject(demo);

The JSONObject jo for this example is going to be:

{"name":"lorem ipsum","active":true,"id":1}

Although we have a way to serialize a Java object to JSON string, there is no way to convert it back using this library.

If we want that kind of flexibility, we can switch to other libraries such as Jackson.

5. JSONArray

A JSONArray is an ordered collection of values, resembling Java's native Vector implementation.

  • Values can be anything from a Number, String, Boolean, JSONArray, JSONObject or even a JSONObject.NULL object
  • It's represented by a String wrapped within Square Brackets and consists of a collection of values separated by commas
  • Like JSONObject, it has a constructor that accepts a source String and parses it to construct a JSONArray

The following are the primary methods of the JSONArray class:

  1. get(int index) – returns the value at the specified index(between 0 and total length – 1), otherwise throws a JSONException
  2. opt(int index) – returns the value associated with an index (between 0 and total length – 1). If there's no value at that index, then a null is returned
  3. put(Object value) – append an object value to this JSONArray. This method is overloaded and supports a wide range of data types

For a complete list of methods supported by JSONArray, visit the official documentation.

5.1. Creating JSONArray

Once we've initialized a JSONArray object, we can simply add and retrieve elements using the put() and get() methods:

JSONArray ja = new JSONArray(); ja.put(Boolean.TRUE); ja.put("lorem ipsum"); JSONObject jo = new JSONObject(); jo.put("name", "jon doe"); jo.put("age", "22"); jo.put("city", "chicago"); ja.put(jo);

Following would be contents of our JSONArray(code is formatted for clarity):

[ true, "lorem ipsum", { "city": "chicago", "name": "jon doe", "age": "22" } ]

5.2. Creating JSONArray Directly from JSON String

Like JSONObject the JSONArray also has a constructor that creates a Java object directly from a JSON String:

JSONArray ja = new JSONArray("[true, \"lorem ipsum\", 215]");

This constructor may throw a JSONException if the source String isn't a valid JSON String.

5.3. Creating JSONArray Directly from a Collection or an Array

The constructor of JSONArray also supports collection and array objects as arguments.

We simply pass them as an argument to the constructor and it will return a JSONArray object:

List list = new ArrayList(); list.add("California"); list.add("Texas"); list.add("Hawaii"); list.add("Alaska"); JSONArray ja = new JSONArray(list);

Now our JSONArray consists of:

["California","Texas","Hawaii","Alaska"]

6. JSONTokener

A JSONTokener takes a source String as input to its constructor and extracts characters and tokens from it. It's used internally by classes of this package (like JSONObject, JSONArray) to parse JSON Strings.

There may not be many situations where we'll directly use this class as the same functionality can be achieved using other simpler methods (like string.toCharArray()):

JSONTokener jt = new JSONTokener("lorem"); while(jt.more()) { Log.info(jt.next()); }

Now we can access a JSONTokener like an iterator, using the more() method to check if there are any remaining elements and next() to access the next element.

The tokens received from the previous example will be:

l o r e m

7. CDL

We're provided with a CDL (Comma Delimited List) class to convert comma delimited text into a JSONArray and vice versa.

7.1. Producing JSONArray Directly from Comma Delimited Text

In order to produce a JSONArray directly from the comma-delimited text, we can use the static method rowToJSONArray() which accepts a JSONTokener:

JSONArray ja = CDL.rowToJSONArray(new JSONTokener("England, USA, Canada"));

Our JSONArray now consists of:

["England","USA","Canada"]

7.2. Producing Comma Delimited Text from JSONArray

In order to reverse of the previous step and get back the comma-delimited text from JSONArray, we can use:

JSONArray ja = new JSONArray("[\"England\",\"USA\",\"Canada\"]"); String cdt = CDL.rowToString(ja);

The Stringcdt now contains:

England,USA,Canada

7.3. Producing JSONArray of JSONObjects Using Comma Delimited Text

To produce a JSONArray of JSONObjects, we'll use a text String containing both headers and data separated by commas.

The different lines are separated using a carriage return (\r) or line feed (\n).

The first line is interpreted as a list of headers and all the subsequent lines are treated as data:

String string = "name, city, age \n" + "john, chicago, 22 \n" + "gary, florida, 35 \n" + "sal, vegas, 18"; JSONArray result = CDL.toJSONArray(string);

The object JSONArray result now consists of (output formatted for the sake of clarity):

[ { "name": "john", "city": "chicago", "age": "22" }, { "name": "gary", "city": "florida", "age": "35" }, { "name": "sal", "city": "vegas", "age": "18" } ]

Notice that in this example, both data and header were supplied within the same String.There's an alternative way of doing this where we can achieve the same functionality by supplying a JSONArray that would be used to get the headers and a comma-delimited String working as the data.

Different lines are separated using a carriage return (\r) or line feed (\n):

JSONArray ja = new JSONArray(); ja.put("name"); ja.put("city"); ja.put("age"); String string = "john, chicago, 22 \n" + "gary, florida, 35 \n" + "sal, vegas, 18"; JSONArray result = CDL.toJSONArray(ja, string);

Here we'll get the contents of object result exactly as before.

8. Cookie

The Cookie class deals with web browser cookies and has methods to convert a browser cookie into a JSONObject and vice versa.

Here are the main methods of the Cookie class:

  1. toJsonObject(String sourceCookie) – converts a cookie string into a JSONObject

  2. toString(JSONObject jo) – this is reverse of the previous method, converts a JSONObject into a cookie String.

8.1. Converting a Cookie String into a JSONObject

To convert a cookie String to a JSONObject, well use the static method Cookie.toJSONObject():

String cookie = "username=John Doe; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/"; JSONObject cookieJO = Cookie.toJSONObject(cookie);

8.2. Converting a JSONObject into Cookie String

Now we'll convert a JSONObject into cookie String. This is reverse of the previous step:

String cookie = Cookie.toString(cookieJO);

9. HTTP

The HTTP class contains static methods that are used to convert HTTP headers to JSONObject and vice versa.

This class also has two main methods:

  1. toJsonObject(String sourceHttpHeader) – converts a HttpHeader String to JSONObject
  2. toString(JSONObject jo) – converts the supplied JSONObject to String

9.1. Converting JSONObject to HTTP Header

HTTP.toString() method is used to convert a JSONObject to HTTP header String:

JSONObject jo = new JSONObject(); jo.put("Method", "POST"); jo.put("Request-URI", "//www.example.com/"); jo.put("HTTP-Version", "HTTP/1.1"); String httpStr = HTTP.toString(jo);

Here, our String httpStr will consist of:

POST "//www.example.com/" HTTP/1.1

Note that while converting an HTTP request header, the JSONObject must contain “Method”,“Request-URI” and “HTTP-Version” keys, whereas, for response header, the object must contain “HTTP-Version”,“Status-Code” and “Reason-Phrase” parameters.

9.2. Converting HTTP Header String Back to JSONObject

Here we will convert the HTTP string that we got in the previous step back to the very JSONObject that we created in that step:

JSONObject obj = HTTP.toJSONObject("POST \"//www.example.com/\" HTTP/1.1");

10. JSONException

The JSONException is the standard exception thrown by this package whenever any error is encountered.

Dies wird für alle Klassen dieses Pakets verwendet. Auf die Ausnahme folgt normalerweise eine Meldung, die angibt, was genau schief gelaufen ist.

11. Schlussfolgerung

In diesem Tutorial haben wir uns einen JSON mit Java - org.json - angesehen und uns auf einige der hier verfügbaren Kernfunktionen konzentriert.

Die vollständigen Codefragmente, die in diesem Artikel verwendet werden, finden Sie auf GitHub.