Introduction à JSON-Java (org.json)

1. Introduction à JSON-Java

JSON (acronyme de JavaScript Object Notation) est un format léger d'échange de données et est le plus couramment utilisé pour la communication client-serveur. Il est à la fois facile à lire / écrire et indépendant de la langue. Une valeur JSON peut être un autre objet JSON , tableau, nombre, chaîne, booléen (vrai / faux) ou null.

Dans ce didacticiel, nous verrons comment créer, manipuler et analyser JSON à l'aide de l'une des bibliothèques de traitement JSON disponibles, c'est-à-dire que la bibliothèque JSON-Java est également connue sous le nom de org.json.

2. Prérequis

Avant de commencer, nous devrons ajouter la dépendance suivante dans notre pom.xml :

 org.json json 20180130 

La dernière version se trouve dans le référentiel Maven Central.

Notez que ce package a déjà été inclus dans le SDK Android, nous ne devons donc pas l'inclure lors de son utilisation.

3. JSON en Java [package org.json]

La bibliothèque JSON-Java est également connue sous le nom org.json (à ne pas confondre avec org.json.simple de Google) nous fournit des classes qui sont utilisées pour analyser et manipuler JSON en Java.

De plus, cette bibliothèque peut également convertir entre JSON, XML, en-têtes HTTP, cookies, liste ou texte délimités par des virgules, etc.

Dans ce tutoriel, nous examinerons:

  1. JSONObject - similaire à l'objetnatif Map de Javaqui stocke des paires clé-valeur non ordonnées
  2. JSONArray - une séquence ordonnée de valeurs similaire à l'implémentation native Vector de Java
  3. JSONTokener - un outil qui divise un morceau de texte en une série de jetons qui peuvent être utilisés par JSONObject ou JSONArray pour analyser les chaînes JSON
  4. CDL - un outil qui fournit des méthodes pour convertir du texte délimité par des virgules en un JSONArray et vice versa
  5. Cookie - convertit de JSON String en cookies et vice versa
  6. HTTP - utilisé pour convertir une chaîne JSONen en-têtes HTTP et vice versa
  7. JSONException - il s'agit d'une exception standard levée par cette bibliothèque

4. JSONObject

Un JSONObject est une collection non ordonnée de paires de clés et de valeurs, ressemblant aux implémentations Map natives de Java .

  • Les clés sont des chaînes uniques qui ne peuvent pas être nulles
  • Les valeurs peuvent être quelque chose d'un Boolean , Number , chaîne , JSONArray ou même un JSONObject.NULL objet
  • Un JSONObject peut être représenté par une chaîne entre accolades avec des clés et des valeurs séparées par deux-points et des paires séparées par une virgule
  • Il a plusieurs constructeurs avec lesquels construire un JSONObject

Il prend également en charge les principales méthodes suivantes:

  1. get (String key) - obtient l'objet associé à la clé fournie, lance JSONException si la clé n'est pas trouvée
  2. opt (String key) - obtient l'objet associé à la clé fournie, null sinon
  3. put (String key, Object value) - insère ou remplace une paire clé-valeur dans le JSONObject actuel .

La méthode put () est une méthode surchargée qui accepte une clé de type String et plusieurs types pour la valeur.

Pour la liste complète des méthodes prises en charge par JSONObject , visitez la documentation officielle.

Discutons maintenant de certaines des principales opérations prises en charge par cette classe.

4.1. Création de JSON directement à partir de JSONObject

JSONObject expose une API similaire à l' interface Map de Java . Nous pouvons utiliser la méthode put () et fournir la clé et la valeur comme argument:

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

Maintenant, notre JSONObject ressemblerait à ceci :

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

Il existe sept signatures surchargées différentes de la méthode JSONObject.put () . Alors que la clé ne peut être qu'une chaîne unique et non nulle , la valeur peut être n'importe quoi.

4.2. Création de JSON à partir de la carte

Au lieu de placer directement la clé et les valeurs dans un JSONObject , nous pouvons construire une carte personnalisée , puis la transmettre comme argument au constructeur de JSONObject .

Cet exemple produira les mêmes résultats que ci-dessus:

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

4.3. Création de JSONObject à partir d'une chaîne JSON

Pour analyser une chaîne JSON en un JSONObject , nous pouvons simplement passer la chaîne au constructeur.

Cet exemple produira les mêmes résultats que ci-dessus:

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

L' argument String passé doit être un JSON valide, sinon ce constructeur peut lever une exception JSONException .

4.4. Sérialiser l'objet Java en JSON

Un des constructeurs de JSONObject prend un POJO comme argument. Dans l'exemple ci-dessous, le package utilise les getters de la classe DemoBean et crée un JSONObject approprié pour le même.

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.

Ceci est utilisé dans toutes les classes de ce package. L'exception est généralement suivie d'un message indiquant ce qui n'a pas fonctionné exactement.

11. Conclusion

Dans ce didacticiel, nous avons examiné un JSON utilisant Java - org.json - et nous nous sommes concentrés sur certaines des fonctionnalités de base disponibles ici.

Les extraits de code complets utilisés dans cet article se trouvent à l'adresse over sur GitHub.