web-dev-qa-db-fra.com

Analyse JSON utilisant Gson pour Java

Je voudrais analyser les données de JSON qui est de type String. J'utilise Google Gson .

J'ai:

jsonLine = "
{
 "data": {
  "translations": [
   {
    "translatedText": "Hello world"
   }
  ]
 }
}
";

et ma classe est:

public class JsonParsing{

   public void parse(String jsonLine) {

      // there I would like to get String "Hello world"

   }

}
javajsongson
146
Martynas

C'est un code simple à faire, j'ai évité toutes les vérifications mais c'est l'idée principale.

 public String parse(String jsonLine) {
    JsonElement jelement = new JsonParser().parse(jsonLine);
    JsonObject  jobject = jelement.getAsJsonObject();
    jobject = jobject.getAsJsonObject("data");
    JsonArray jarray = jobject.getAsJsonArray("translations");
    jobject = jarray.get(0).getAsJsonObject();
    String result = jobject.get("translatedText").getAsString();
    return result;
}

Pour rendre l'utilisation plus générique - vous constaterez que les javadocs de Gson sont assez clairs et utiles.

227
MByD

Dans ma première application gson, j’évitais d’utiliser des classes supplémentaires pour capturer des valeurs, principalement parce que json était utilisé pour les questions de configuration.

malgré le manque d'informations (même page gson), c'est ce que j'ai trouvé et utilisé:

partant de

Map jsonJavaRootObject = new Gson().fromJson("{/*whatever your mega complex object*/}", Map.class)

Chaque fois que gson voit un {}, il crée une carte (en fait un gson StringMap)

Chaque fois que gson voit un '', il crée une chaîne

Chaque fois que gson voit un nombre, il crée un double

Chaque fois que gson voit un [], il crée un ArrayList

Vous pouvez utiliser ces faits (combinés) à votre avantage

Enfin c'est le code qui fait la chose

        Map<String, Object> javaRootMapObject = new Gson().fromJson(jsonLine, Map.class);

    System.out.println(
        (
            (Map)
            (
                (List)
                (
                    (Map)
                    (
                        javaRootMapObject.get("data")
                    )
                 ).get("translations")
            ).get(0)
        ).get("translatedText")
    );
106
Jorge Sanchez

La chose la plus simple consiste généralement à créer une hiérarchie d'objet correspondante, comme suit:

public class Wrapper {
   public Data data;
}
static class Data {
   public Translation[] translations;
}
static class Translation {
   public String translatedText;
}

puis liez en utilisant GSON, traversez la hiérarchie des objets via des champs. L'ajout de getters et de setters est inutile pour les conteneurs de données de base.

Donc, quelque chose comme:

Wrapper value = GSON.fromJSON(jsonString, Wrapper.class);
String text = value.data.translations[0].translatedText;
19
StaxMan

Vous pouvez créer les classes Java correspondantes pour les objets JSON. Le nombre entier, les valeurs de chaîne peuvent être mappés tels quels. Json peut être analysé comme ceci-

Gson gson = new GsonBuilder().create(); 
Response r = gson.fromJson(jsonString, Response.class);

Voici un exemple - http://rowsandcolumns.blogspot.com/2013/02/url-encode-http-get-solr-request-and.html

14
Harpreet

Vous pouvez utiliser une classe distincte pour représenter l'objet JSON et utiliser les annotations @SerializedName pour spécifier le nom du champ à saisir pour chaque membre de données:

public class Response {

   @SerializedName("data")
   private Data data;

   private static class Data {
      @SerializedName("translations")
      public Translation[] translations;
   }

   private static class Translation {
      @SerializedName("translatedText")
      public String translatedText;
   }

   public String getTranslatedText() {
      return data.translations[0].translatedText;
   }
}

Ensuite, vous pouvez analyser votre méthode parse () en utilisant un objet Gson:

Gson gson = new Gson();
Response response = gson.fromJson(jsonLine, Response.class);

System.out.println("Translated text: " + response.getTranslatedText());

Avec cette approche, vous pouvez réutiliser la classe Response pour ajouter d’autres champs supplémentaires permettant de collecter d’autres membres de données que vous souhaitez extraire du fichier JSON. traductions en un seul appel, ou pour obtenir une chaîne supplémentaire pour la langue source détectée.

7
rmtheis

Utiliser Gson pour résoudre
Je créerais une classe pour un paramètre individuel dans la chaîne json. Vous pouvez également créer une classe principale appelée "Données", puis créer les classes internes de la même manière. J'ai créé des classes séparées pour plus de clarté.

Les cours sont les suivants.

  • Les données
  • Traductions
  • TranslatedText

Dans la classe JsonParsing la méthode "parse" nous appelons gson.fromJson(jsonLine, Data.class) qui convertira la chaîne en objets Java à l'aide de Reflection.

Une fois que nous avons accès à l'objet "Data", nous pouvons accéder à chaque paramètre individuellement.

Je n'ai pas eu l'occasion de tester ce code car je suis loin de ma machine de développement. Mais cela devrait aider.

Quelques bons exemples et articles.
http://albertattard.blogspot.com/2009/06/exemple-pratique-de-gson.html
http://sites.google.com/site/gson/gson-user-guide

Code 

public class JsonParsing{

       public void parse(String jsonLine) {

           Gson gson = new GsonBuilder().create();
           Data data = gson.fromJson(jsonLine, Data.class);

           Translations translations = data.getTranslation();
           TranslatedText[] arrayTranslatedText = translations.getArrayTranslatedText(); //this returns an array, based on json string

           for(TranslatedText translatedText:arrayTranslatedText )
           {
                  System.out.println(translatedText.getArrayTranslatedText());
           }
       }

    }


    public class Data{
           private  Translations translations;
          public Translations getTranslation()
          {
             return translations;
          }

          public void setTranslation(Translations translations)
           {
                  this.translations = translations;
           }
    }

    public class Translations
    {
        private  TranslatedText[] translatedText;
         public TranslatedText[] getArrayTranslatedText()
         {
             return translatedText;
         }

           public void setTranslatedText(TranslatedText[] translatedText)
           {
                  this.translatedText= translatedText;
           }
    }

    public class TranslatedText
    {
        private String translatedText;
        public String getTranslatedText()
        {
           return translatedText;
        }

        public void setTranslatedText(String translatedText)
        {
           this.translatedText = translatedText;
        }
    }
5
kensen john

Un chemin serait créé un JsonObject et itérant à travers les paramètres. Par exemple

JsonObject jobj = new Gson().fromJson(jsonString, JsonObject.class);

Ensuite, vous pouvez extraire des valeurs de bean comme:

String fieldValue = jobj.get(fieldName).getAsString();
boolean fieldValue = jobj.get(fieldName).getAsBoolean();
int fieldValue = jobj.get(fieldName).getAsInt();

J'espère que cela t'aides.

4
Anand Tuli

Vous pouvez utiliser une requête JsonPath pour extraire la valeur. Et avec JsonSurfer qui est soutenu par Gson, votre problème peut être résolu en deux lignes de code!

    JsonSurfer jsonSurfer = JsonSurfer.gson();
    String result = jsonSurfer.collectOne(jsonLine, String.class, "$.data.translations[0].translatedText");
2
Leo Wang

Tout d'abord générer Getter And Setter en utilisant le site d'analyse ci-dessous

http://www.jsonschema2pojo.org/

Maintenant, utilisez Gson

GettetSetterClass object=new Gson().fromjson(jsonLine,GettetSetterClass.class);

Maintenant, utilisez objet pour obtenir des valeurs telles que data, translationText

2
Nilesh Panchal
    JsonParser parser = new JsonParser();
    JsonObject jo = (JsonObject) parser.parse(data);
    JsonElement je = jo.get("some_array");

    //Parsing back the string as Array
    JsonArray ja = (JsonArray) parser.parse(o.get("some_array").getAsString());
    for (JsonElement jo : ja) {
    JsonObject j = (JsonObject) jo;
        // Your Code, Access json elements as j.get("some_element")
    }

Un exemple simple pour analyser un JSON comme celui-ci

{"some_array": "[\" some_element\": 1, \" some_more_element\": 2]", "some_other_element": 3}

2
Rahul Malhotra

Un code de ligne:

System.out.println(new Gson().fromJson(jsonLine,JsonObject.class).getAsJsonObject().get("data").getAsJsonObject().get("translations").getAsJsonArray().get(0).getAsJsonObject().get("translatedText").getAsString());
1
retArdos