HOWTO · Java
Convertir une chaîne de caractères en objet JSON en Java
Ce tutoriel explique comment convertir une chaîne de caractères en un objet json en java
Sur cette page
Pour utiliser du texte JSON en Java, analysez-le avec une bibliothèque JSON. L’analyse produit un arbre JSON propre à la bibliothèque que vous pouvez inspecter dynamiquement ; mapper le texte sur une classe Java produit en revanche un objet typé. Les trois options présentées ici sont org.json, Gson et Jackson. Chacune nécessite sa propre dépendance. Choisissez un arbre lorsque vous voulez inspecter les champs dynamiquement, ou mappez le texte sur une classe Java lorsque la forme des données est connue et que des champs typés sont utiles.
Utilisez JSONObject pour convertir une chaîne de caractères en objet JSON en Java
La bibliothèque JSON-java (org.json) analyse une chaîne d’objet avec new JSONObject(json). Pour Maven, ajoutez org.json:json:20201115 à l’intérieur de l’élément <dependencies> de pom.xml. Le constructeur renvoie un JSONObject ; lisez les membres chaîne et entier avec getString("name") et getInt("age"). Ces appels renvoient des valeurs Java, tandis que le JSONObject reste la représentation en mémoire de l’objet JSON propre à la bibliothèque. Récupérez les membres par clé, car l’ordre des membres d’un objet n’est pas une propriété sémantique fiable.
L’exemple complet ci-dessous utilise new JSONObject(json) pour analyser l’exemple partagé {"name":"John","age":30}, lit et affiche les deux champs, et gère JSONException :
import org.json.JSONException;
import org.json.JSONObject;
public class StringToJsonObjectWithJsonOrg {
public static void main(String[] args) {
String json = "{\"name\":\"John\",\"age\":30}";
try {
JSONObject object = new JSONObject(json);
System.out.println("name: " + object.getString("name"));
System.out.println("age: " + object.getInt("age"));
} catch (JSONException e) {
System.err.println("Invalid JSON: " + e.getMessage());
}
}
}
name: John
age: 30
À titre de comparaison, l’exemple ci-dessous, qui n’utilise que le JDK, extrait lui aussi les deux champs de l’exemple et affiche leurs valeurs, à l’aide d’une simple expression régulière. Il est limité à cette forme d’entrée plate ; il n’analyse ni ne valide du JSON général. L’entrée est déclarée dans main, enregistrez donc l’extrait sous le nom StringToJsonObject.java et compilez-le avec un JDK.
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class StringToJsonObject {
public static void main(String[] args) {
String json = "{\"name\":\"John\",\"age\":30}";
Pattern field = Pattern.compile("\\\"(name|age)\\\"\\s*:\\s*(?:\\\"([^\\\"]*)\\\"|(\\d+))");
Matcher matcher = field.matcher(json);
Map<String, String> values = new LinkedHashMap<>();
while (matcher.find()) {
String value = matcher.group(2) != null ? matcher.group(2) : matcher.group(3);
values.put(matcher.group(1), value);
}
System.out.println("name: " + values.get("name"));
System.out.println("age: " + values.get("age"));
}
}
name: John
age: 30
Cette expression régulière ne couvre que les membres chaîne et entier affichés. Elle ne valide pas la syntaxe JSON et ne gère pas correctement les guillemets échappés, les structures imbriquées, les tableaux ou d’autres valeurs JSON. Utilisez JSONObject ou un autre analyseur pour les entrées de l’application, et vérifiez que les membres requis existent et ont les types attendus avant de les lire. Capturez JSONException autour de l’analyse et des lectures typées afin que l’appelant puisse signaler un échec d’analyse ou d’accès à une valeur, ou s’en remettre.
Utilisez Google Gson pour convertir une chaîne de caractères en objet JSON en Java
Gson peut analyser du texte en un arbre JSON ou le mapper directement sur une classe Java. Pour inspecter des champs sans définir de classe, ajoutez com.google.code.gson:gson:2.8.6 à l’intérieur de l’élément <dependencies> de Maven. Analysez un arbre avec JsonParser.parseString(json).getAsJsonObject(), puis lisez les membres avec object.get("name").getAsString() et object.get("age").getAsInt(). Cela renvoie un arbre JsonObject, et non une instance d’une classe de domaine.
L’exemple complet ci-dessous analyse le même exemple en un JsonObject, lit et affiche les deux champs, et gère les erreurs d’analyse :
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;
public class StringToJsonObjectWithGson {
public static void main(String[] args) {
String json = "{\"name\":\"John\",\"age\":30}";
try {
JsonObject object = JsonParser.parseString(json).getAsJsonObject();
System.out.println("name: " + object.get("name").getAsString());
System.out.println("age: " + object.get("age").getAsInt());
} catch (JsonParseException | IllegalStateException e) {
System.err.println("Invalid JSON: " + e.getMessage());
}
}
}
name: John
age: 30
Si les données ont une forme connue et que des champs typés sont utiles, définissez une classe User avec les champs String name et int age, puis appelez new Gson().fromJson(json, User.class) pour produire un User. Pour sérialiser cette instance en texte JSON, appelez new Gson().toJson(user). GsonBuilder.setPrettyPrinting() configure la mise en forme pendant la sérialisation ; cela ne change ni l’arbre analysé ni la valeur Java. Gérez JsonParseException pour les problèmes d’analyse, puis validez les champs requis, car un JSON valide peut tout de même omettre des données dont votre programme a besoin.
Utilisez Jackson pour convertir une chaîne de caractères en objet JSON
Le modèle d’arbre de Jackson est utile lorsque vous devez sélectionner des champs dynamiquement. Ajoutez com.fasterxml.jackson.core:jackson-databind:2.11.3 à l’intérieur de l’élément <dependencies> de Maven. L’artefact jackson-databind fournit l’API d’arbre ObjectMapper et apporte Jackson core comme dépendance. Appelez new ObjectMapper().readTree(json) pour analyser le texte en un JsonNode, la représentation d’arbre JSON de Jackson. Lisez les valeurs de l’exemple avec node.get("name").asText() et node.get("age").asInt() ; utilisez le membre correspondant pour chaque valeur.
L’exemple complet ci-dessous utilise ObjectMapper.readTree(json), lit et affiche les deux champs, et gère l’exception contrôlée JsonProcessingException :
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class StringToJsonObjectWithJackson {
public static void main(String[] args) {
String json = "{\"name\":\"John\",\"age\":30}";
try {
JsonNode node = new ObjectMapper().readTree(json);
System.out.println("name: " + node.get("name").asText());
System.out.println("age: " + node.get("age").asInt());
} catch (JsonProcessingException e) {
System.err.println("Invalid JSON: " + e.getMessage());
}
}
}
name: John
age: 30
readTree peut lever l’exception contrôlée JsonProcessingException, gérez-la donc à l’endroit où l’analyse a lieu. Vérifiez également que chaque nœud demandé existe et a le type attendu avant d’utiliser des accesseurs pratiques tels que asText() ou asInt(). Sinon, un membre manquant ou d’un autre type peut produire une valeur qui ne convient pas à l’application, même lorsque le document JSON lui-même a été analysé avec succès.
Les trois bibliothèques analysent du texte JSON, mais leurs types d’arbre et leurs API diffèrent : JSONObject, JsonObject et JsonNode. Un document mal formé échoue pendant l’analyse, et la classe et le message de l’exception dépendent de la bibliothèque choisie. L’analyse seule ne garantit pas que les champs requis sont présents ni que les valeurs ont les types attendus par votre application, validez-les donc avant de les utiliser. L’exemple d’expression régulière qui n’utilise que le JDK est limité à l’exemple plat affiché ; utilisez l’une des API de bibliothèque avec dépendance pour les entrées JSON générales.