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"
         }
    ]
}
801
demandé sur Mark Amery 2010-04-07 13:00:21
la source

30 ответов

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

604
répondu user1931858 2018-05-15 13:39:04
la source

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
426
répondu SDekov 2016-04-01 22:42:18
la source
  1. 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);
    
  2. 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");
    
74
répondu nondescript 2018-08-25 02:45:44
la source

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);
63
répondu rputta 2017-02-27 16:18:25
la source

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.

27
répondu dade 2015-12-16 16:51:12
la source

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
25
répondu Levent Divilioglu 2016-07-12 22:42:59
la source

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 .

21
répondu lubilis 2018-10-09 02:29:06
la source

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>
20
répondu Sakib Sami 2018-02-04 21:48:29
la source

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

16
répondu Giovanni Botta 2015-08-14 03:04:25
la source

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.

13
répondu justin.hughey 2016-05-03 00:58:36
la source

ç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.

10
répondu brainmurphy1 2016-01-15 22:45:29
la source

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.

10
répondu otonglet 2018-02-05 12:18:38
la source

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.

7
répondu Shailendra Singh 2015-10-06 21:08:30
la source

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;
}
7
répondu Viacheslav Vedenin 2015-12-17 00:23:39
la source

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:

  1. Performance
  2. facilité d'utilisation (le code est simple à écrire et lisible) - qui va avec les caractéristiques.
  3. 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.

7
répondu fabien 2016-06-29 08:09:56
la source

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

    }
}

`

6
répondu venkat 2016-02-05 09:19:24
la source

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:

Comment parser du JSON en Java

6
répondu lalitbhagtani 2018-02-04 22:00:41
la source

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
}
5
répondu LittleBigUllah 2017-10-19 20:20:03
la source

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");
4
répondu Sreekanth 2015-07-14 07:23:16
la source
{
   "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
}
3
répondu LReddy 2015-07-28 17:40:36
la source

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:

  1. 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();
    
  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;
    
3
répondu yurin 2016-07-23 17:46:43
la source

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!

3
répondu Jose Manuel Gomez Alvarez 2017-05-23 15:34:44
la source

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 .

3
répondu sumit kumar 2018-02-04 21:38:47
la source

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
2
répondu Ravi Durairaj 2018-02-04 21:45:58
la source

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>
2
répondu Parth Solanki 2018-02-04 21:51:26
la source

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.

0
répondu Jaroslav Tulach 2017-11-21 10:43:55
la source

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\"}");
0
répondu slashron 2018-02-04 21:56:45
la source

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));
  }
}
0
répondu smith 2018-02-04 22:01:47
la source

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.

0
répondu Niravdas 2018-09-21 21:10:25
la source

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();

}
}
-2
répondu Akash Roy 2018-05-17 12:34:14
la source

Autres questions sur java json parsing