L'organisation .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 plus d'exemples de: Analyser JSON en Java

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

Pour le bien de l'exemple, supposons 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 (Je ne sais pas si c'est le cas.]}

Mon préféré 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"}

Mise à Jour

Si vous voulez obtenir un seul attribut, vous pouvez le faire facilement avec la bibliothèque de Google ainsi:

JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John

Org.JSON (Je ne sais pas si c'est le cas.]}

Si vous n'avez pas besoin désérialisation d'objet mais pour simplement obtenir 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 (Je ne sais pas si c'est le cas.]}

ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);

System.out.println(user.name); //John

1. Si l'on veut créer un objet Java à partir de JSON et vice versa, utilisez des pots 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 on veut juste analyser une chaîne JSON et obtenir des valeurs, (OU créer une chaîne JSON à partir de zéro pour l'envoyer sur wire), utilisez simplement JaveEE jar qui contient JsonReader, JsonArray, JsonObject etc. Vous voudrez peut-être télécharger l'implémentation de cette spécification 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");
   

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

Caractéristiques:

• Conforme à la spécification JSON (RFC4627)
• Analyseur JSON haute performance
• Prend en charge l'approche d'analyse flexible/configurable
• Validation configurable des paires clé/valeur de toute hiérarchie JSON
• Facile à utiliser # Très faible encombrement
• Soulève les exceptions conviviales et faciles à tracer pour les développeurs
• Enfichable Prise en charge de la validation personnalisée-Les clés/valeurs peuvent être validées en configurant les validateurs personnalisés au fur et à mesure
• Validation et non-validation du support de l'analyseur
• 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
• Aucune dépendance vis-à-vis des bibliothèques externes
• Prise en charge de la génération JSON via la sérialisation d'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);

Presque toutes les réponses données nécessitent une désérialisation complète du JSON en 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 voie, consiste à utiliser JSONPath qui est comme XPath pour JSON et permet de traverser des objets JSON.

C'est une spécification et les bonnes personnes de JayWay ont créé une implémentation Java pour la spécification que vous pouvez trouver ici: https://github.com/jayway/JsonPath

Donc en gros pour l'utiliser, ajoutez à 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 de spécification JSONPath pour plus d'informations sur les autres façons de transverse JSON.

Une Explication

Vous pouvez utiliser les bibliothèques Jackson , pour lier une chaîne JSON dans POJO (Ancien Objet Java Simple) instances. POJO est simplement une classe avec uniquement des champs privés et des méthodes getter/setter publiques. Jackson va parcourir les méthodes (en utilisant reflection ) et mappe l'objet JSON dans l'instance POJO car 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 objet composite , l'objet principal est constitué de deux sous-objets. Donc, nos classes POJO devraient avoir la même hiérarchie. J'appellerai l'objet JSON entier en tant qu'objet Page. Page objet se composent d'un PageInfo objet, et un Post - tableau d'objets.

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

• Page Classe, un composite de PageInfo Classe et un ensemble de Post - Les Instances
• PageInfo Classe
• Messages 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-noyau-2.5.1.jar
• jackson-databind-2.5.1.jar
• jackson-annotations-2.5.0.jar

Voici le code requis;

B-Classe POJO principale : 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;
    }

}

Classe C-Enfant POJO: 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-Classe POJO enfant: 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-Exemple de fichier JSON : sampleJSONFile.json

Je viens de copier votre exemple JSON dans ce fichier et de 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());
    }

}

Sortie G-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, il vous suffit de créer un modèle avec la même structure JSON. Ensuite, le modèle est automatiquement remplie. Vous devez appeler vos variables en tant que 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 online des outils comme ce.

Utiliser minimes-json, 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:

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>

Je pense que la meilleure pratique devrait être de passer par l'API Java JSON officielle qui est toujours en cours.

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 json (qui est mentionnée dans certaines des autres réponses). La raison pour laquelle je l'ai ajouté comme réponse distincte est que le code suivant montre comment en fait accéder à certaines des valeurs affichées dans la question. Une implémentation du javax.l'API json serait nécessaire pour exécuter ce code. Le paquet complet pour chacun des les classes requises ont été incluses car je ne voulais pas déclarer les instructions "importer".

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 ne descende cette réponse car il n'utilise pas GSON, org.json, Jackson ou l'un des autres frameworks tiers 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'était pas envisagée pour JDK 9 et en tant que telle, la spécification JSR 353 devrait être traitée comme identique à toute autre implémentation de gestion JSON tierce.

Cela m'a soufflé à quel point c'était facile. Vous pouvez simplement passer un String contenant votre JSON au constructeur d'un JSONObject dans l'organisation par défaut.paquet json.

JSONArray rootOfPage =  new JSONArray(JSONString);

Terminé. Gouttes microphone. Cela fonctionne également avec JSONObjects. Après cela, vous pouvez simplement parcourir votre hiérarchie de Objects en utilisant les méthodes get() sur vos objets.

Puisque personne ne l'a encore mentionné, voici le début d'une solution utilisant Nashorn (partie d'exécution JavaScript 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 obtenir les 100 éléments du troisième tableau. J'utilise la fonction JavaScript suivante pour analyser et obtenir mes entrées.

var fun = function(raw) {JSON.parse(raw).entries};

Exécution de l'appel un million de fois en utilisant Nashorn prend 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 fonctionne mieux que Nashorn, qui fonctionne beaucoup mieux que org.json. Nashorn API est plus difficile à utiliser que org.json ou Jackson. Selon vos besoins Jackson et Nashorn peuvent tous deux être des solutions viables.

Si vous avez une classe Java (disons Message) représentant la chaîne JSON(jsonString), vous pouvez utiliser Jackson bibliothèque JSON avec:

Message message= new ObjectMapper().readValue(jsonString, Message.class);

Et à partir de l'objet 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 pour générer rapidement des classes Java à partir du schéma json ou json pour 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 notoires sont: Jackson, GSON, Genson, FastJson et org.json.

Il y a généralement trois choses à considérer pour choisir une bibliothèque:

1. Performance
2. Facilité d'utilisation (le code est simple à écrire et lisible) - cela va avec les fonctionnalités.
3. Pour les applications mobiles: dépendance / taille du pot

Spécifiquement pour les bibliothèques JSON (et toutes les bibliothèques de sérialisation / désérialisation), la liaison de données est également généralement intéressante car elle supprime la nécessité d'écrire du code de plaque de chaudière pour emballer/décompresser les données.

Pour 1, voir ce repère: https://github.com/fabienrenaud/java-json-benchmarkJ'ai utilisé JMH qui compare (jackson, gson, genson, fastjson, org.json, jsonp) performance des sérialiseurs et des désérialiseurs à l'aide des API stream et databind. Pour 2, vous pouvez trouver de nombreux exemples sur Internet. L'indice de référence ci-dessus peut également être utilisé comme source de exemple...

Rapide à emporter de la 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.
    }
}

Faites-moi savoir si vous avez des questions.

Gson est facile à apprendre et à mettre en œuvre, ce que nous devons savoir est de suivre deux méthodes

• la méthode toJson() – Convertir Java objet au format JSON

• Dejson() – Convertir JSON en objet Java

`

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 des valeurs JSON. Votre exigence est juste de lire les valeurs et de les analyser en objet personnalisé. Donc org.la bibliothèque json est suffisante dans votre cas.

Utiliser l'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:

Comment analyser JSON en Java

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 parcourir le tableau "posts"comme suit:

JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
  String postId = post.getAsJsonObject().get("post_id").getAsString();
  //do something
}

Veuillez 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
}

Les meilleures réponses sur cette page utilisent des exemples trop simples comme object with one property (par exemple {name: value}). Je pense que cet exemple de vie encore simple mais réel peut aider quelqu'un.

Voici donc le JSON renvoyé 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 Gson de Google.

Deux approches possibles:

1. Récupérer un seul 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();
   

2. Créer Java objet 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 ce faire.

L'API Java pour le traitement JSON (JSR 353) fournit des API portables pour analyser, générer, transformer et interroger JSON à l'aide d'API de modèle d'objet et de streaming.

Le l'implémentation de référence de est ici: https://jsonp.java.net/

Ici vous pouvez trouver une liste des implémentations{[2] } de JSR 353:

Quelles sont les API qui implémentent JSR-353 (JSON)

Et pour vous aider à décider... J'ai également trouvé cet article:

Http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json/

Si vous optez pour Jackson, voici un bon article sur la conversion entre JSON vers / depuis Java en utilisant Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

J'espère que ça aide!

Lisez l'article de blog suivant, JSON en Java .

Ce post est un peu vieux, mais je veux toujours 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 plus de référence, vous pouvez vous référer au lien suivant.

Vous pouvez utiliser Jayway JSONPath. Vous trouverez ci-dessous un lien GitHub avec le code source, les détails 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 à l'aide de 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 : Veuillez enregistrer votre JSON d'entrée en tant que fichier pour cet exemple. Dans mon cas, j'ai enregistré votre JSON sous sampleJson.txt. Notez que vous avez manqué une virgule entre pageInfo et posts.

Étape 3 : Lisez le contenu JSON du fichier ci-dessus à l'aide de bufferedReader et enregistrez-le en tant que chaîne.

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 à l'aide de l'analyseur jayway JSON.

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"
    }
}

La classe Java

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Code pour convertir ce JSON en une 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 annotationpour créer des classes de modèle Javareprésentant la structure des fichiers JSONet les utiliser pour accéder à divers éléments de l'arborescence JSON. Contrairement à d'autres solutions, celle-ci fonctionne complètement sans réflexion et convient donc aux environnements où la réflexion est impossible ou avec des frais généraux importants.

Il est un exemple de projet Maven montrant l'utilisation. 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 {
    }
}

Puis il utilise les classes RepositoryInfo et Owner générées pour analyser le flux d'entrée fourni et récupérer 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 tout! En plus de cela, voici unlive gist montrant un exemple similaire avec une communication réseau asynchrone.

Vous pouvez utiliser JsonNode pour une représentation arborescente structurée de votre chaîne JSON. Ça fait partie du solide comme le roc jackson library qui est omniprésente.

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 une virgule entre deux données json "pageInfo" et "posts".

Les données json valides sont les suivantes

{
   "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, il s'agit d'une donnée json valide , vous pouvez l'analyser en utilisant l'un des mathods décrits 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 nœuds de votre arborescence 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 essayer 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();

}
}