web-dev-qa-db-fra.com

Comment analyser JSON dans Java

J'ai le texte JSON suivant. Comment puis-je l'analyser pour obtenir les valeurs de 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"
         }
    ]
}
javajsonparsing
944
Muhammad Maqsoodur Rehman

La bibliothèque org.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: Parse JSON en Java

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

686
user1931858

Par 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 quant à la grande sérialisation JSON/dé-sérialisation 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 souhaitez obtenir un seul attribut, vous pouvez également 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 la désérialisation d'objet mais simplement d'obtenir un attribut, vous pouvez essayer org.json ( ou regarder 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
500
SDekov

  1. Si vous voulez créer un objet Java à partir de JSON et inversement, utilisez des fichiers tiers tels que GSON ou JACKSON.

    //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 seulement analyser une chaîne JSON et obtenir des valeurs, (OU créer une chaîne JSON à partir de zéro pour l'envoyer sur le réseau), utilisez simplement le jar JaveEE qui contient JsonReader, JsonArray, JsonObject, etc. Vous pouvez télécharger l'implémentation de celui-ci. spec comme javax.json. Avec ces deux pots, je suis capable d'analyser le JSON et d'utiliser les valeurs.

    Ces API suivent en réalité 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");
96
nondescript

quick-json parser est très simple, flexible, très rapide et personnalisable. L'essayer

Fonctionnalités:

  • Conforme à la spécification JSON (RFC4627)
  • Analyseur JSON hautes performances
  • 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
  • Améliore la facilité de développement des développeurs et facilite le suivi des exceptions
  • Prise en charge de la validation personnalisée pouvant être connectée - Les clés/valeurs peuvent être validées en configurant des validateurs personnalisés au fur et à mesure qu'ils sont rencontrés
  • 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 sur les 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 lors du processus d'analyse

Il peut être utilisé comme ceci:

JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);
70
rputta

A - Explication

Vous pouvez utiliser les bibliothèques Jackson pour relier JSON String à POJO ( Plain Old Java Object ) instances. POJO est simplement une classe avec uniquement des champs privés et des méthodes de lecture/définition publiques. Jackson va parcourir les méthodes (à l'aide de 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 objet composite, l'objet principal est constitué de deux sous-objets. Ainsi, nos classes POJO devraient avoir la même hiérarchie. J'appellerai l'objet JSON entier en tant qu'objet Page. Page objet se compose d'un objet PageInfo, et d'un tableau Post.

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

  • Page Classe, composé de PageInfo Classe et tableau d'instances Post
  • PageInfo Classe
  • Messages Classe

Le seul package que j'ai utilisé est Jackson ObjectMapper, ce que nous faisons est de lier des 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 - Classe principale de POJO: 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 Classe 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 - Enfant Classe POJO: 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 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());
    }

}

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
35
Levent Divilioglu

Presque toutes les réponses fournies nécessitent une désérialisation complète du JSON en un objet Java avant d'accéder à la valeur de la propriété d'intérêt. Une autre alternative, qui ne va pas dans cette voie, consiste à utiliser JsonPATH , qui ressemble à XPath pour JSON et permet de parcourir les objets JSON.

C'est une spécification et les gens de JayWay ont créé une implémentation de la spécification Java 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 de spécification JsonPath pour plus d'informations sur les autres manières de traverser JSON.

34
dade

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. Le modèle est ensuite automatiquement renseigné. 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 à l'aide d'outils en ligne tels que this .

31
lubilis

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

Échantillon 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>
24
Sakib Sami

Je pense que la meilleure pratique devrait être de passer par la version officielle Java JSON API qui est toujours en cours de développement.

19
Giovanni Botta

L'exemple ci-dessous montre comment lire le texte de la question, représenté par la variable "jsonText". Cette solution utilise l'API Java EE7 javax.json (mentionnée dans certaines des autres réponses). La raison pour laquelle je l'ai ajouté en tant que réponse distincte est que le code suivant montre comment accéder en fait à certaines des valeurs indiquées dans la question. Un implémentation de l'API javax.json serait nécessaire pour que ce code soit exécuté. Le package complet pour chacune des classes requises était inclus car je ne voulais pas déclarer d'instructions "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 quiconque ne veuille réduire la réponse parce qu'il n'utilise pas GSON, org.json, Jackson ou aucun des autres frameworks tiers disponibles, il s'agit d'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, le JSR 353 spec devrait être traité de la même manière que tout autre tiers. Mise en œuvre de la gestion JSON.

18
justin.hughey

Comme personne ne l’a encore mentionné, voici le début d’une solution utilisant Nashorn (composant d’exécution JavaScript de Java 8, mais obsolète dans Java 11).

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

L'exécution de l'appel un million de fois à l'aide de Nashorn prend entre 7,5 et 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. L'API de Nashorn est plus difficile à utiliser que celle de org.json ou de Jackson. Selon vos besoins, Jackson et Nashorn peuvent constituer des solutions viables.

16
otonglet

Cela m'a frappé avec la facilité. Vous pouvez simplement passer un String contenant votre code JSON au constructeur d'un objet JSON dans le package org.json par défaut.

JSONArray rootOfPage =  new JSONArray(JSONString);

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

14
brainmurphy1

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 présente également un intérêt, car elle supprime la nécessité d'écrire du code de plaque chauffante pour compresser/décompresser les données.

Pour 1, voir ce repère: https://github.com/fabienrenaud/Java-json-benchmark J'ai utilisé JMH qui compare (jackson, gson, genson). , fastjson, org.json, jsonp) performances des sérialiseurs et des desérialisateurs à l'aide d'API stream et databind. Pour 2, vous pouvez trouver de nombreux exemples sur Internet. Le repère ci-dessus peut également être utilisé comme source d’exemples ...

Résultat rapide: Jackson est 5 à 6 fois meilleur que org.json et plus de deux fois meilleur 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.

12
fabien

En plus d'autres réponses, je recommande ce service opensource en ligne jsonschema2pojo.org pour générer rapidement des classes Java à partir de schémas 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 a 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;
}
10
Viacheslav Vedenin

Il existe de nombreuses bibliothèques open source pour analyser le contenu JSON en un objet ou simplement pour lire les valeurs JSON. Votre exigence est simplement de lire les valeurs et de les analyser en objet personnalisé. La bibliothèque org.json est donc suffisante dans votre cas.

Utilisez la bibliothèque org.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

9
lalitbhagtani

Si vous avez une classe Java (par exemple, Message) représentant la chaîne JSON (jsonString), vous pouvez utiliser la bibliothèque JSON Jackson 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.

9
Shailendra Singh

Gson est facile à apprendre et à mettre en œuvre. Ce que nous devons savoir, suivent deux méthodes.

  • toJson () - Convertit l'objet Java au format JSON

  • fromJson () - 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();
    }

    }
}

`

8
venkat

S'il vous plaît faire quelque chose comme ça:

JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");
7
Sreekanth

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" de la manière suivante:

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

Lisez le blog suivant, JSON en Java .

Ce message est un peu vieux, mais je veux quand même 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érences, vous pouvez vous référer au suivant lien .

6
sumit kumar
{
   "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
}
4
LReddy

Vous devez d'abord sélectionner une bibliothèque d'implémentation pour le faire.

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

L'implémentation de référence est ici: https://jsonp.Java.net/

Vous trouverez ici une liste des implémentations de JSR 353:

Quelles sont les API qui implémentent 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 optez pour Jackson, voici un bon article sur la conversion JSON vers/de Java utilisant Jackson: https://www.mkyong.com/Java/how-to-convert- Objet-a-de-json-jackson /

J'espère que ça aide!

4
Jose Manuel Gomez Alvarez

Les réponses les plus fréquentes sur cette page utilisent des exemples trop simples, tels qu'un objet avec une propriété (par exemple, {nom: valeur}). Je pense que cet exemple de vie 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 "translateText", par exemple. "Arbeit" en utilisant Google Gson.

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 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;
4
yurin

Vous pouvez utiliser Jayway JsonPath . Ci-dessous, un lien GitHub avec le code source, des 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 du chemin JSON de jayway 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 entrée JSON en tant que fichier pour cet exemple. Dans mon cas, j'ai enregistré votre JSON sous le nom 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 sous forme de 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 JSON de jayway.

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
3
Ravi Durairaj

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 permettant de 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>
2
Parth Solanki

jsoniter (jsoniterator) est une bibliothèque json relativement nouvelle et simple, conçue pour être simple et rapide. Tout ce que vous devez faire pour désérialiser les données JSON est

JsonIterator.deserialize(jsonData, int[].class);

où jsonData est une chaîne de données json.

Consultez le site officiel pour plus d'informations.

2
Pika the Wizard of the Whales

Vous pouvez utiliser la bibliothèque d'analyse de flux DSM pour analyser les documents JSON et XML complexes. DSM analyse les données une seule fois et ne charge pas toutes les données en mémoire.

Disons que nous avons la classe Page pour désérialiser les données JSON données.

Classe de page

public class Page {
    private String pageName;
    private String pageImage;
    private List<Sting> postIds;

    // getter/setter

}

Créez un fichier de mappage yaml.

result:
  type: object     # result is array
  path: /posts
  fields:
    pageName:
        path: /pageInfo/pageName
    pageImage:
        path: /pageInfo/pagePic
    postIds:
      path: post_id
      type: array

Utilisez DSM pour extraire des champs.

DSM dsm=new DSMBuilder(new File("path-to-yaml-config.yaml")).create(Page.class);
Page page= (Page)dsm.toObject(new path-to-json-data.json");

page variable sérialisée en json:

{
  "pageName" : "abc",
  "pageImage" : "http://example.com/content.jpg",
  "postIds" : [ "123456789012_123456789012" ]
}

DSM est très bon pour les fichiers json et xml complexes.

1
mfe

On peut utiliser annotation Apache @Model pour créer des classes de modèle Java représentant la structure de JSON et utilisez-les pour accéder à divers éléments de l’arbre JSON. Contrairement aux autres solutions, celle-ci fonctionne complètement sans réflexion et convient donc aux environnements dans lesquels la réflexion est impossible ou entraîne des coûts importants.

Il y a 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 {
    }
}

il utilise ensuite 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 procédant de la sorte:

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 Gist en direct montrant un exemple similaire avec une communication réseau asynchrone.

1
Jaroslav Tulach

Nous pouvons utiliser la classe JSONObject pour convertir une chaîne JSON en objet JSON et effectuer une itération 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));
  }
}
1
smith

Vous pouvez utiliser JsonNode pour une représentation arborescente de votre chaîne JSON. Cela fait partie de la roche solide jackson bibliothèque qui est omniprésent.

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");
0
slashron