Question Comment analyser JSON en Java


J'ai le texte JSON suivant. 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"
         }
    ]
}

762
2018-04-07 09:00


origine


Réponses:


le org.json La bibliothèque 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 plus d'exemples de: Parse JSON en Java

Pot téléchargeable: http://mvnrepository.com/artifact/org.json/json


575
2017-09-25 06:56



Par souci de l'exemple laisse supposer que vous avez 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 quant à la grande sérialisation / désérialisation JSON des 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"}

Mettre à jour

Si vous voulez obtenir un seul attribut, 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 d'une sérialisation de l'objet mais simplement d'un attribut, vous pouvez essayer org.json (ou regardez l'exemple GSON 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

409
2017-07-31 09:54



  1. Si l'on veut créer un objet JAVA à partir de JSON et vice versa, utiliser des bocaux tiers GSON ou JACKSON, etc.

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
    
  2. Mais si l'on veut simplement analyser une chaîne JSON et obtenir des valeurs, (OU créer une chaîne JSON à partir de zéro pour envoyer par câble), utilisez JaveEE jar qui contient JsonReader, JsonArray, JsonObject etc. Vous pouvez télécharger l'implémentation de cette spec comme javax.json. Avec ces deux pots, je suis capable d'analyser le json et d'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");
    

68
2018-02-18 23:34



parser rapide-json est très simple, flexible, très rapide et personnalisable. Essayez-le

Caractéristiques:

  • Conforme à la spécification JSON (RFC4627)
  • Parser JSON haute performance
  • Prend en charge une approche d'analyse flexible / configurable
  • Validation configurable des paires clé / valeur de toute hiérarchie JSON
  • Facile à utiliser # Très petit encombrement
  • Soulève les exceptions favorables aux développeurs et faciles à tracer
  • Prise en charge de la validation personnalisée Pluggable - Les clés / valeurs peuvent être validées en configurant des validateurs personnalisés au fur et à mesure des problèmes rencontrés
  • Validation et non-validation de l'analyseur
  • Prise en charge de deux types de configuration (JSON / XML) pour l'utilisation de l'analyseur de validation rapide JSON
  • Nécessite JDK 1.5
  • Aucune dépendance sur les bibliothèques externes
  • Prise en charge de la génération JSON via la sérialisation des objets
  • Prise en charge de 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);

61
2018-02-24 06:24



Presque toutes les réponses données nécessitent une désé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 le déplacement d'objets JSON.

C'est une spécification et les bons gars 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 d'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 de spécification JsonPath pour plus d'informations sur les autres façons de transiter JSON.


25
2017-12-16 13:51



A - Explication

Vous pouvez utiliser Jackson bibliothèques, pour lier la chaîne JSON dans POJO (Objet Java ancien) instances. POJO est simplement une classe avec seulement des champs privés et des méthodes getter / setter publiques. Jackson va traverser les méthodes (en utilisant réflexion) et mappe l'objet JSON dans l'instance POJO lorsque les noms de champ de la classe correspondent aux noms de champ de l'objet JSON.

Dans votre objet JSON, qui est en fait un composite objet, l'objet principal consiste en deux sous-objets. Ainsi, nos classes POJO devraient avoir la même hiérarchie. J'appellerai l'ensemble de l'objet JSON Page objet. Page objet consiste en un PageInfo objet, et un Poster tableau d'objets.

Nous devons donc créer trois classes de POJO différentes;

  • Page Classe, un composé de PageInfo Classe et tableau de Poster Instances
  • PageInfo Classe
  • Des postes Classe

Le seul paquet que j'ai utilisé est Jackson ObjectMapper, ce que nous faisons est la liaison de données;

com.fasterxml.jackson.databind.ObjectMapper

Les dépendances requises, les fichiers jar sont listé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 Classe: 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 - Enfant POJO Classe: 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 - Enfant POJO Classe: Poste

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 - Exemple de fichier JSON: sampleJSONFile.json

Je viens de copier votre exemple JSON dans ce fichier et le placer dans le dossier du 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 - Sortie de démonstration

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

24
2017-07-12 19:06



Vous pourriez utiliser Google Gson.

En utilisant cette bibliothèque, il vous suffit de créer un modèle avec la même structure JSON. Ensuite, le modèle est automatiquement rempli. Vous devez appeler vos variables comme vos clés JSON ou utiliser @SerializedName si vous souhaitez 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 un modèle à partir de JSON automatiquement en utilisant des outils en ligne comme ce.


20
2018-06-01 15:20



Utilisation minimal-json ce qui est très rapide et facile à utiliser. Vous pouvez analyser à partir de String obj et Stream.

Exemple de données:

{
  "order": 4711,
  "items": [
    {
      "name": "NE555 Timer IC",
      "cat-id": "645723",
      "quantity": 10,
    },
    {
      "name": "LM358N OpAmp IC",
      "cat-id": "764525",
      "quantity": 2
    }
  ]
}

Analyse syntaxique

JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();

Création de 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>

19
2017-08-15 19:57



Je crois que la meilleure pratique devrait être de passer par le API Java JSON qui sont encore en cours.


14
2018-04-08 17:37



L'exemple ci-dessous montre comment lire le texte de la question, représentée par la variable "jsonText". Cette solution utilise le Java EE7 javax.json API (qui est mentionné dans certaines des 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. Un implémentation de l'API javax.json serait nécessaire pour faire fonctionner ce code. Le package complet pour chacune des classes requises a été inclus car je ne voulais pas déclarer les instructions "import".

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 n'aille contrevient à cette réponse parce qu'il n'utilise pas GSON, org.json, Jackson, ou n'importe lequel des frameworks tiers disponibles, c'est un exemple de "code requis" par la question pour analyser le texte fourni. Je suis bien conscient que le respect de la norme actuelle JSR 353 n'était pas envisagé pour le JDK 9 et en tant que tel JSR 353 spec doit être traité de la même manière que toute autre implémentation JSON tierce.


12
2018-05-02 21:58