Comment analyser JSON en Java
j'ai le texte suivant de JSON. Comment puis-je l'analyser pour obtenir pageName
, pagePic
, post_id
, etc.?
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
30 réponses
Le org.la bibliothèque json est facile à utiliser. Exemple de code ci-dessous:
import org.json.*;
JSONObject obj = new JSONObject(" .... ");
String pageName = obj.getJSONObject("pageInfo").getString("pageName");
JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
String post_id = arr.getJSONObject(i).getString("post_id");
......
}
vous pouvez trouver d'autres exemples à partir de: Parse JSON in Java
pot téléchargeable: http://mvnrepository.com/artifact/org.json/json
pour les besoins de l'exemple, supposons que vous ayez une classe Person
avec juste un name
.
private class Person {
public String name;
public Person(String name) {
this.name = name;
}
}
Google Gson ( Maven )
Mon favori personnel de la grande JSON de la sérialisation / dé-sérialisation d'objets.
Gson g = new Gson();
Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John
System.out.println(g.toJson(person)); // {"name":"John"}
mise à Jour
Si vous voulez obtenir un vous pouvez le faire facilement avec la Bibliothèque Google:
JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();
System.out.println(jsonObject.get("name").getAsString()); //John
Org.JSON ( Maven )
si vous n'avez pas besoin de dé-serialisation d'objet mais simplement d'obtenir un attribut, vous pouvez essayer org.json ( ou chercher GSON exemple ci-dessus! )
JSONObject obj = new JSONObject("{\"name\": \"John\"}");
System.out.println(obj.getString("name")); //John
Jackson ( Maven )
ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);
System.out.println(user.name); //John
-
si l'on veut créer un objet Java à partir de JSON et vice versa, utilisez Gson ou JACKSON third party jars etc.
//from object to JSON Gson gson = new Gson(); gson.toJson(yourObject); // from JSON to object yourObject o = gson.fromJson(JSONString,yourObject.class);
-
mais si l'on veut simplement analyser une chaîne JSON et obtenir quelques valeurs, (ou créer une chaîne JSON à partir de zéro pour envoyer par fil) il suffit D'utiliser JaveEE jar qui contient JsonReader, JsonArray, JsonObject etc. Vous pouvez télécharger l'implémentation de cette spécification comme javax.json. Avec ces deux jars je peux analyser le json et utiliser les valeurs.
ces API suivent en fait le modèle D'analyse DOM/SAX de XML.
Response response = request.get(); // REST call JsonReader jsonReader = Json.createReader(new StringReader(response.readEntity(String.class))); JsonArray jsonArray = jsonReader.readArray(); ListIterator l = jsonArray.listIterator(); while ( l.hasNext() ) { JsonObject j = (JsonObject)l.next(); JsonObject ciAttr = j.getJsonObject("ciAttributes");
quick-parser json est très simple, flexible, très rapide et personnalisable. Essayez
Dispose:
- conforme à la spécification JSON (RFC4627)
- Haute Performance parser JSON
- prend en charge L'approche D'analyse Flexible/Configurable
- Configurable validation de paires clé/valeur de toute JSON Hiérarchie
- Facile à utiliser # très petite empreinte
- soulève des exceptions conviviales pour les développeurs et faciles à retracer
- support de Validation personnalisé-les clés/valeurs peuvent être validées en configurant des validateurs personnalisés au fur et à mesure de leur découverte
- la Validation et la Non-Validation de l'analyseur de soutien
- prise en charge de deux types de configuration (JSON/XML) pour l'utilisation de l'analyseur de validation quick-JSON
- nécessite JDK 1.5
- pas de dépendance à l'égard des bibliothèques externes
- Support de JSON Génération par le biais de l'objet de la sérialisation
- Support pour la sélection du type de collection pendant le processus d'analyse
il peut être utilisé comme ceci:
JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);
presque toutes les réponses données nécessitent une desérialisation complète du JSON dans un objet Java avant d'accéder à la valeur dans la propriété d'intérêt. Une autre alternative, qui ne va pas dans cette direction, est d'utiliser JsonPATH qui est comme XPath pour JSON et permet de traverser des objets JSON.
il s'agit d'une spécification et les gens de JayWay ont créé une implémentation Java pour la spécification que vous pouvez trouver ici: https://github.com/jayway/JsonPath
donc fondamentalement pour l'utiliser, ajoutez-le à votre projet, par exemple:
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>${version}</version>
</dependency>
et à utiliser:
String pageName = JsonPath.read(yourJsonString, "$.pageInfo.pageName");
String pagePic = JsonPath.read(yourJsonString, "$.pageInfo.pagePic");
String post_id = JsonPath.read(yourJsonString, "$.pagePosts[0].post_id");
etc...
consultez la page spécification de JsonPath pour plus d'informations sur les autres façons de JSON transversal.
A-Explication
vous pouvez utiliser Jackson bibliothèques, pour lier chaîne JSON dans POJO ( simple Old Java Object ) instances. POJO est simplement une classe avec seulement des champs privés et des méthodes publiques getter/setter. Jackson va parcourir les méthodes (en utilisant reflection ), et mappe L'objet JSON dans L'instance de POJO comme les noms de champs de la classe correspondent aux noms de champs de l'objet JSON.
dans votre objet JSON, qui est en fait un composite objet, l'objet principal se compose de deux sous-objets. Donc, nos classes de POJO devraient avoir la même hiérarchie. Je vais appeler tout L'objet JSON comme page objet. Page objet composent d'une PageInfo objet, et un Post tableau d'objets.
nous devons donc créer trois classes POJO différentes;
- Page de la Classe, un composite de PageInfo de la Classe et un ensemble de Post Instances
- PageInfo Class
- Posts Class
le seul paquet que j'ai utilisé est Jackson ObjectMapper, ce que nous faisons est de la liaison de données;
com.fasterxml.jackson.databind.ObjectMapper
les dépendances requises, les fichiers jar sont énumérés ci-dessous;
- jackson-core-2.5.1.jar
- jackson-databind-2.5.1.jar
- jackson-annotations-2.5.0.jar
voici le code requis;
B-Main POJO Class: Page
package com.levo.jsonex.model;
public class Page {
private PageInfo pageInfo;
private Post[] posts;
public PageInfo getPageInfo() {
return pageInfo;
}
public void setPageInfo(PageInfo pageInfo) {
this.pageInfo = pageInfo;
}
public Post[] getPosts() {
return posts;
}
public void setPosts(Post[] posts) {
this.posts = posts;
}
}
C-Child POJO Class: PageInfo
package com.levo.jsonex.model;
public class PageInfo {
private String pageName;
private String pagePic;
public String getPageName() {
return pageName;
}
public void setPageName(String pageName) {
this.pageName = pageName;
}
public String getPagePic() {
return pagePic;
}
public void setPagePic(String pagePic) {
this.pagePic = pagePic;
}
}
D-Child POJO Class: Post
package com.levo.jsonex.model;
public class Post {
private String post_id;
private String actor_id;
private String picOfPersonWhoPosted;
private String nameOfPersonWhoPosted;
private String message;
private int likesCount;
private String[] comments;
private int timeOfPost;
public String getPost_id() {
return post_id;
}
public void setPost_id(String post_id) {
this.post_id = post_id;
}
public String getActor_id() {
return actor_id;
}
public void setActor_id(String actor_id) {
this.actor_id = actor_id;
}
public String getPicOfPersonWhoPosted() {
return picOfPersonWhoPosted;
}
public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
this.picOfPersonWhoPosted = picOfPersonWhoPosted;
}
public String getNameOfPersonWhoPosted() {
return nameOfPersonWhoPosted;
}
public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getLikesCount() {
return likesCount;
}
public void setLikesCount(int likesCount) {
this.likesCount = likesCount;
}
public String[] getComments() {
return comments;
}
public void setComments(String[] comments) {
this.comments = comments;
}
public int getTimeOfPost() {
return timeOfPost;
}
public void setTimeOfPost(int timeOfPost) {
this.timeOfPost = timeOfPost;
}
}
e-Sample JSON File: sampleJSONFile.json
je viens de copier votre échantillon JSON dans ce fichier et de le placer sous le dossier projet.
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
},
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
F - Code De Démonstration
package com.levo.jsonex;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.levo.jsonex.model.Page;
import com.levo.jsonex.model.PageInfo;
import com.levo.jsonex.model.Post;
public class JSONDemo {
public static void main(String[] args) {
ObjectMapper objectMapper = new ObjectMapper();
try {
Page page = objectMapper.readValue(new File("sampleJSONFile.json"), Page.class);
printParsedObject(page);
} catch (IOException e) {
e.printStackTrace();
}
}
private static void printParsedObject(Page page) {
printPageInfo(page.getPageInfo());
System.out.println();
printPosts(page.getPosts());
}
private static void printPageInfo(PageInfo pageInfo) {
System.out.println("Page Info;");
System.out.println("**********");
System.out.println("\tPage Name : " + pageInfo.getPageName());
System.out.println("\tPage Pic : " + pageInfo.getPagePic());
}
private static void printPosts(Post[] posts) {
System.out.println("Page Posts;");
System.out.println("**********");
for(Post post : posts) {
printPost(post);
}
}
private static void printPost(Post post) {
System.out.println("\tPost Id : " + post.getPost_id());
System.out.println("\tActor Id : " + post.getActor_id());
System.out.println("\tPic Of Person Who Posted : " + post.getPicOfPersonWhoPosted());
System.out.println("\tName Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
System.out.println("\tMessage : " + post.getMessage());
System.out.println("\tLikes Count : " + post.getLikesCount());
System.out.println("\tComments : " + Arrays.toString(post.getComments()));
System.out.println("\tTime Of Post : " + post.getTimeOfPost());
}
}
G - La Production De Démo
Page Info;
****(*****
Page Name : abc
Page Pic : http://example.com/content.jpg
Page Posts;
**********
Post Id : 123456789012_123456789012
Actor Id : 1234567890
Pic Of Person Who Posted : http://example.com/photo.jpg
Name Of Person Who Posted : Jane Doe
Message : Sounds cool. Can't wait to see it!
Likes Count : 2
Comments : []
Time Of Post : 1234567890
vous pouvez utiliser Google Gson .
en utilisant cette bibliothèque, vous n'avez qu'à créer un modèle avec la même structure JSON. Ensuite, le modèle est automatiquement remplie. Vous devez appeler vos variables comme vos clés JSON, ou utiliser @SerializedName si vous voulez utiliser des noms différents.
pour votre exemple:
JSON:
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
Modèle:
class MyModel {
private PageInfo pageInfo;
private ArrayList<Post> posts = new ArrayList<>();
}
class PageInfo {
private String pageName;
private String pagePic;
}
class Post {
private String post_id;
@SerializedName("actor_id") // <- example SerializedName
private String actorId;
private String picOfPersonWhoPosted;
private String nameOfPersonWhoPosted;
private String message;
private String likesCount;
private ArrayList<String> comments;
private String timeOfPost;
}
Maintenant, vous pouvez analyser en utilisant la bibliothèque Gson:
MyModel model = gson.fromJson(jsonString, MyModel.class);
vous pouvez générer le modèle à partir de JSON automatiquement en utilisant des outils en ligne comme ce .
Utiliser minimal-json , qui est très rapide et facile à utiliser. Vous pouvez Parser de String obj et Stream.
les données de l'Échantillon:
{
"order": 4711,
"items": [
{
"name": "NE555 Timer IC",
"cat-id": "645723",
"quantity": 10,
},
{
"name": "LM358N OpAmp IC",
"cat-id": "764525",
"quantity": 2
}
]
}
Analyse:
JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();
Creating JSON:
JsonObject user = Json.object().add("name", "Sakib").add("age", 23);
Maven:
<dependency>
<groupId>com.eclipsesource.minimal-json</groupId>
<artifactId>minimal-json</artifactId>
<version>0.9.4</version>
</dependency>
je pense que la meilleure pratique devrait être de passer par le API Java JSON qui sont encore en cours de travail.
L'exemple ci-dessous montre comment lire le texte de la question, représenté par la variable" jsonText". Cette solution utilise le Java EE7 javax.API de json (mentionnée dans d'autres réponses). La raison pour laquelle je l'ai ajouté comme réponse séparée est que le code suivant montre comment réellement accéder à certaines des valeurs indiquées dans la question. Une implémentation du javax.L'API JSON serait requise pour rendre ce code exécuté. Le paquet complet pour chacune des classes requises a été inclus car je ne voulais pas déclarer des déclarations "d'importation".
javax.json.JsonReader jr =
javax.json.Json.createReader(new StringReader(jsonText));
javax.json.JsonObject jo = jr.readObject();
//Read the page info.
javax.json.JsonObject pageInfo = jo.getJsonObject("pageInfo");
System.out.println(pageInfo.getString("pageName"));
//Read the posts.
javax.json.JsonArray posts = jo.getJsonArray("posts");
//Read the first post.
javax.json.JsonObject post = posts.getJsonObject(0);
//Read the post_id field.
String postId = post.getString("post_id");
maintenant, avant que quelqu'un s'en aille et dévalorise cette réponse parce qu'elle n'utilise pas Gson, org.json, Jackson, ou n'importe lequel des cadres de tierce partie disponibles, c'est un exemple de "code requis" par la question pour analyser le texte fourni. Je suis bien conscient que l'adhésion à la norme actuelle JSR 353 n'a pas été étant considéré pour JDK 9 et en tant que tel le JSR 353 spec devrait être traité de la même façon que n'importe quel autre JSON tierce partie la mise en œuvre de manipulation.
ça m'a épaté à quel point c'était facile. Vous pouvez simplement passer un String
tenant votre JSON au constructeur D'un JSONObject dans l'org par défaut.paquet json.
JSONArray rootOfPage = new JSONArray(JSONString);
fait. Gouttes microphone .
Cela fonctionne aussi avec JSONObjects
. Après cela, vous pouvez simplement regarder à travers votre hiérarchie de Objects
en utilisant les méthodes get()
sur vos objets.
comme personne ne l'a encore mentionné, voici le début d'une solution utilisant Nashorn (partie JavaScript runtime de Java 8).
Solution
private static final String EXTRACTOR_SCRIPT =
"var fun = function(raw) { " +
"var json = JSON.parse(raw); " +
"return [json.pageInfo.pageName, json.pageInfo.pagePic, json.posts[0].post_id];};";
public void run() throws ScriptException, NoSuchMethodException {
ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
engine.eval(EXTRACTOR_SCRIPT);
Invocable invocable = (Invocable) engine;
JSObject result = (JSObject) invocable.invokeFunction("fun", JSON);
result.values().forEach(e -> System.out.println(e));
}
comparaison des Performances
j'ai écrit du contenu JSON contenant trois tableaux de respectivement 20, 20 et 100 éléments. Je veux seulement les 100 éléments du Troisième tableau. J'utilise le suivant la fonction JavaScript pour analyser et obtenir mes entrées.
var fun = function(raw) {JSON.parse(raw).entries};
l'Exécution de l'appel d'un million de fois à l'aide de Nashorn prend de 7,5~7,8 secondes
(JSObject) invocable.invokeFunction("fun", json);
org.json prend 20~21 secondes
new JSONObject(JSON).getJSONArray("entries");
Jackson prend 6.5~7 secondes
mapper.readValue(JSON, Entries.class).getEntries();
dans ce cas, Jackson se comporte mieux que Nashorn, qui effectue beaucoup mieux que org.json. L'API Nashorn est plus difficile à utiliser que org.chez json ou Jackson. En fonction de vos besoins, Jackson et Nashorn peuvent être des solutions viables.
si vous avez une classe Java(Message say) représentant la chaîne JSON (jsonString), vous pouvez utiliser Jackson bibliothèque JSON avec:
Message message= new ObjectMapper().readValue(jsonString, Message.class);
et de l'objet de message vous pouvez récupérer n'importe lequel de ses attributs.
en plus d'autres réponses, je recommande ce service opensource en ligne jsonschema2pojo.org for quick generating Java classes from json or json schema for GSON, Jackson 1.X ou Jackson 2.x. Par exemple, si vous avez:
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": 1234567890,
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": 2,
"comments": [],
"timeOfPost": 1234567890
}
]
}
Le jsonschema2pojo.org pour GSON généré:
@Generated("org.jsonschema2pojo")
public class Container {
@SerializedName("pageInfo")
@Expose
public PageInfo pageInfo;
@SerializedName("posts")
@Expose
public List<Post> posts = new ArrayList<Post>();
}
@Generated("org.jsonschema2pojo")
public class PageInfo {
@SerializedName("pageName")
@Expose
public String pageName;
@SerializedName("pagePic")
@Expose
public String pagePic;
}
@Generated("org.jsonschema2pojo")
public class Post {
@SerializedName("post_id")
@Expose
public String postId;
@SerializedName("actor_id")
@Expose
public long actorId;
@SerializedName("picOfPersonWhoPosted")
@Expose
public String picOfPersonWhoPosted;
@SerializedName("nameOfPersonWhoPosted")
@Expose
public String nameOfPersonWhoPosted;
@SerializedName("message")
@Expose
public String message;
@SerializedName("likesCount")
@Expose
public long likesCount;
@SerializedName("comments")
@Expose
public List<Object> comments = new ArrayList<Object>();
@SerializedName("timeOfPost")
@Expose
public long timeOfPost;
}
il existe de nombreuses bibliothèques JSON disponibles en Java.
les plus célèbres sont Jackson, Gson, Genson, FastJson et org.json.
il y a typiquement trois choses que l'on devrait regarder pour choisir n'importe quelle bibliothèque:
- Performance
- facilité d'utilisation (le code est simple à écrire et lisible) - qui va avec les caractéristiques.
- pour applications mobiles: dépendance / jar size
spécifiquement pour les bibliothèques JSON (et toutes les bibliothèques de serialization/deserialization libs), databinding est également d'un intérêt général car il supprime la nécessité d'écrire un code chaudière-Plaque pour emballer/déballer les données.
Pour 1, voir ce test: https://github.com/fabienrenaud/java-json-benchmark je l'ai fait à l'aide de JMH qui compare (jackson, gson, genson, fastjson, org.json, jsonp) rendement de sérialiseurs et deserializers à l'aide de flux et databind Api. Pour 2, vous pouvez trouver de nombreux exemples sur Internet. Le benchmark ci-dessus peut également être utilisé comme source d'exemples...
Rapide à emporter de l'indice de référence: Jackson effectue 5 à 6 fois mieux que org.json et plus de deux fois mieux que GSON.
pour votre exemple particulier, le code suivant décode votre json avec jackson:
public class MyObj {
private PageInfo pageInfo;
private List<Post> posts;
static final class PageInfo {
private String pageName;
private String pagePic;
}
static final class Post {
private String post_id;
@JsonProperty("actor_id");
private String actorId;
@JsonProperty("picOfPersonWhoPosted")
private String pictureOfPoster;
@JsonProperty("nameOfPersonWhoPosted")
private String nameOfPoster;
private String likesCount;
private List<String> comments;
private String timeOfPost;
}
private static final ObjectMapper JACKSON = new ObjectMapper();
public static void main(String[] args) throws IOException {
MyObj o = JACKSON.readValue(args[0], MyObj.class); // assumes args[0] contains your json payload provided in your question.
}
}
dites-moi si vous avez des questions.
Gson est facile à apprendre et à mettre en œuvre, ce que nous avons besoin de savoir sont deux méthodes suivantes
-
la méthode toJson() – Convertir en objet Java au format JSON
-
fromJson () - Convert JSON into Java object
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.google.gson.Gson;
public class GsonExample {
public static void main(String[] args) {
Gson gson = new Gson();
try {
BufferedReader br = new BufferedReader(
new FileReader("c:\file.json"));
//convert the json string back to object
DataObject obj = gson.fromJson(br, DataObject.class);
System.out.println(obj);
} catch (IOException e) {
e.printStackTrace();
}
}
}
`
il existe de nombreuses bibliothèques open source présentes pour analyser le contenu JSON d'un objet ou simplement pour lire les valeurs JSON. Votre exigence est juste de lire les valeurs et de les analyser à l'objet personnalisé. So org.la bibliothèque json est suffisante dans votre cas.
Utiliser org.bibliothèque json pour l'analyser et créer JsonObject:
JSONObject jsonObj = new JSONObject(<jsonStr>);
Maintenant, utilisez cet objet pour obtenir vos valeurs:
String id = jsonObj.getString("pageInfo");
Vous pouvez voir un exemple complet ici:
vous pouvez utiliser la bibliothèque Gson pour analyser la chaîne JSON.
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(jsonAsString, JsonObject.class);
String pageName = jsonObject.getAsJsonObject("pageInfo").get("pageName").getAsString();
String pagePic = jsonObject.getAsJsonObject("pageInfo").get("pagePic").getAsString();
String postId = jsonObject.getAsJsonArray("posts").get(0).getAsJsonObject().get("post_id").getAsString();
vous pouvez également boucler la boucle à travers le tableau "posts" de la façon suivante:
JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
String postId = post.getAsJsonObject().get("post_id").getAsString();
//do something
}
s'il vous Plaît faire quelque chose comme ceci:
JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
},
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
Java code :
JSONObject obj = new JSONObject(responsejsonobj);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");
JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
String post_id = arr.getJSONObject(i).getString("post_id");
......etc
}
Top des réponses sur cette page, utilisez trop d'exemples simples comme objet avec une propriété (par exemple, {nom: value}). Je pense que l'exemple encore simple mais réel peut aider quelqu'un.
donc c'est le JSON retourné par L'API Google Translate:
{
"data":
{
"translations":
[
{
"translatedText": "Arbeit"
}
]
}
}
je veux récupérer la valeur de l'attribut" translatedText "par exemple" Arbeit " en utilisant Google Gson.
deux approches possibles:
-
récupérer juste un attribut nécessaire
String json = callToTranslateApi("work", "de"); JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject(); return jsonObject.get("data").getAsJsonObject() .get("translations").getAsJsonArray() .get(0).getAsJsonObject() .get("translatedText").getAsString();
-
Créer un objet Java à partir de JSON
class ApiResponse { Data data; class Data { Translation[] translations; class Translation { String translatedText; } } }
...
Gson g = new Gson(); String json =callToTranslateApi("work", "de"); ApiResponse response = g.fromJson(json, ApiResponse.class); return response.data.translations[0].translatedText;
vous devez d'abord sélectionner une bibliothèque d'implémentation pour faire cela.
L'API Java pour le traitement JSON (JSR 353) fournit des API portables pour analyser, générer, transformer et interroger JSON en utilisant un modèle d'objet et des API de streaming.
Le implémentation de référence est ici: https://jsonp.java.net/
Ici vous pouvez trouver un liste des implémentations de la JSR 353:
Qu'est-ce que L'API qui ne met en œuvre JSR-353 (JSON)
et pour vous aider à décider ... J'ai aussi trouvé cet article:
http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json /
Si vous allez pour Jackson, voici un bon article à propos de la conversion entre JSON et/ou Java en utilisant Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson /
Espère que cela aide!
lire le billet de blog suivant, JSON en Java .
Ce post est un peu vieux, mais je veux répondre à votre question.
Étape 1: créez une classe POJO de vos données.
Étape 2: Créez maintenant un objet en utilisant JSON.
Employee employee = null;
ObjectMapper mapper = new ObjectMapper();
try{
employee = mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
}
catch (JsonGenerationException e){
e.printStackTrace();
}
pour de plus amples informations, vous pouvez vous référer au lien suivant .
vous pouvez utiliser Jayway JsonPath . Ci-dessous, un lien GitHub avec le code source, les détails de pom et une bonne documentation.
https://github.com/jayway/JsonPath
veuillez suivre les étapes ci-dessous.
Étape 1 : ajoutez la dépendance jayway JSON path dans votre chemin de classe en utilisant Maven ou téléchargez le fichier JAR et ajoutez-le manuellement.
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.2.0</version>
</dependency>
Étape 2 : enregistrez votre JSON d'entrée comme fichier pour cet exemple. Dans mon cas, j'ai sauvé votre JSON comme sampleJson.txt. Remarque vous avez oublié une virgule entre pageInfo et des postes.
Étape 3 : lisez le contenu JSON du fichier ci-dessus en utilisant bufferedReader et enregistrez-le sous forme de chaîne de caractères.
BufferedReader br = new BufferedReader(new FileReader("D:\sampleJson.txt"));
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
br.close();
String jsonInput = sb.toString();
Étape 4 : Analysez votre chaîne JSON en utilisant jayway JSON parser.
Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonInput);
Étape 5 : lisez les détails comme ci-dessous.
String pageName = JsonPath.read(document, "$.pageInfo.pageName");
String pagePic = JsonPath.read(document, "$.pageInfo.pagePic");
String post_id = JsonPath.read(document, "$.posts[0].post_id");
System.out.println("$.pageInfo.pageName " + pageName);
System.out.println("$.pageInfo.pagePic " + pagePic);
System.out.println("$.posts[0].post_id " + post_id);
la sortie sera :
$.pageInfo.pageName = abc
$.pageInfo.pagePic = http://example.com/content.jpg
$.posts[0].post_id = 123456789012_123456789012
j'ai JSON comme ceci:
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
}
}
classe Java
class PageInfo {
private String pageName;
private String pagePic;
// Getters and setters
}
Code pour convertir ce JSON en classe Java.
PageInfo pageInfo = JsonPath.parse(jsonString).read("$.pageInfo", PageInfo.class);
Maven
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.2.0</version>
</dependency>
on peut utiliser Apache @Model annotation pour créer Java les classes de modèles représentant la structure des fichiers JSON et les utiliser pour accéder à divers éléments dans l'arbre JSON . Contrairement à d'autres solutions, celle-ci fonctionne complètement sans réflexion et est donc adapté pour les environnements où la réflexion est impossible ou vient avec une hauteur significative au-dessus.
il y a un exemple de projet Maven montrant l'usage. Tout d'abord, il définit la structure:
@Model(className="RepositoryInfo", properties = {
@Property(name = "id", type = int.class),
@Property(name = "name", type = String.class),
@Property(name = "owner", type = Owner.class),
@Property(name = "private", type = boolean.class),
})
final class RepositoryCntrl {
@Model(className = "Owner", properties = {
@Property(name = "login", type = String.class)
})
static final class OwnerCntrl {
}
}
et ensuite il utilise les classes Repopitanyinfo et Owner générées pour analyser le flux d'entrée fourni et ramasser certaines informations tout en faisant cela:
List<RepositoryInfo> repositories = new ArrayList<>();
try (InputStream is = initializeStream(args)) {
Models.parse(CONTEXT, RepositoryInfo.class, is, repositories);
}
System.err.println("there is " + repositories.size() + " repositories");
repositories.stream().filter((repo) -> repo != null).forEach((repo) -> {
System.err.println("repository " + repo.getName() +
" is owned by " + repo.getOwner().getLogin()
);
})
C'est ça! En plus de cela, Voici un LIVE gist montrant un exemple similaire avec asynchrone réseau de communication.
vous pouvez utiliser JsonNode
pour une représentation arborescente structurée de votre chaîne JSON. Il fait partie du solide rocheux jackson library qui est omniprésent.
ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");
nous pouvons utiliser la classe JSONObject pour convertir une chaîne JSON en objet JSON, et pour itérer sur l'objet JSON. Utilisez le code suivant.
JSONObject jObj = new JSONObject(contents.trim());
Iterator<?> keys = jObj.keys();
while( keys.hasNext() ) {
String key = (String)keys.next();
if ( jObj.get(key) instanceof JSONObject ) {
System.out.println(jObj.getString(String key));
}
}
tout d'abord, ce n'est pas une donnée JSON valide
vous devez mettre virgule entre deux données json" pageInfo "et"posts".
valide les données json est comme ci-dessous
{
"pageInfo": {
"pageName": "abc",
"pagePic": "http://example.com/content.jpg"
},
"posts": [
{
"post_id": "123456789012_123456789012",
"actor_id": "1234567890",
"picOfPersonWhoPosted": "http://example.com/photo.jpg",
"nameOfPersonWhoPosted": "Jane Doe",
"message": "Sounds cool. Can't wait to see it!",
"likesCount": "2",
"comments": [],
"timeOfPost": "1234567890"
}
]
}
ici maintenant qu'il s'agit d'une donnée JSON valide , Vous pouvez l'analyser en utilisant l'une des méthodes décrites ci-dessus. ou si vous implémentez cette bibliothèque alors c'est mieux.
vous devez utiliser la classe Jsonnode et ObjectMapper de la bibliothèque jackson pour récupérer les noeuds de votre arbre Json.Ajoutez la dépendance ci-dessous dans votre pom.xml pour obtenir un accès aux classes Jackson.
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
</dependency>
vous devez donner un essai sur le code ci-dessous, cela fonctionnerait:
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
Class JsonNodeExtractor{
public void convertToJson(){
String filepath = "c:\data.json";
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(filepath);
// create a JsonNode for every root or subroot element in the Json String
JsonNode pageInfoRoot = node.path("pageInfo");
// Fetching elements under 'pageInfo'
String pageName = pageInfoRoot.path("pageName").asText();
String pagePic = pageInfoRoot.path("pagePic").asText();
// Now fetching elements under posts
JsonNode postsNode = node.path("posts");
String post_id = postsNode .path("post_id").asText();
String nameOfPersonWhoPosted = postsNode
.path("nameOfPersonWhoPosted").asText();
}
}