Analyse JSON à L'aide de Gson pour Java

Dans ma première application gson, j'ai évité d'utiliser des classes supplémentaires pour attraper des valeurs principalement parce que j'utilise json pour les questions de configuration

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

À partir de

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

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

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

La chose la plus simple est généralement de créer une hiérarchie d'objets correspondante, comme ceci:

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

Puis lier en utilisant GSON, traverser la hiérarchie des objets via les 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;

Vous pouvez créer des classes java correspondantes pour les objets json. Les valeurs entières, chaîne peuvent être mappées telles quelles. 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

Vous pouvez utiliser une classe distincte pour représenter L'objet JSON et utiliser des 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 faire l'analyse dans 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 pour récupérer d'autres membres de données que vous pourriez vouloir extraire de JSON-au cas où vous souhaiteriez apporter des modifications pour obtenir des résultats pour, disons, plusieurs traductions en une seule appel, ou pour obtenir une chaîne supplémentaire pour la langue source détectée.

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 "Data", puis créer des classes internes de la même manière. J'ai créé des classes séparées pour plus de clarté.

Les classes sont les suivantes.

• Données
• Traductions
• TranslatedText

Dans la classe JsonParsing la méthode "parse" nous appelons gson.fromJson(jsonLine, Data.class) qui convertira la chaîne dans les objets java en utilisant Réflexion.

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

N'a pas eu l'occasion de tester ce code car je suis loin de ma machine de développement. Mais cela devrait vous aider.

Quelques bons exemples et articles.
http://albertattard.blogspot.com/2009/06/practical-example-of-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;
        }
    }

    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 ceci

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

Tout D'abord générer Getter et 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 object pour obtenir des valeurs telles que data, translationText

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 par simplement deux lignes de code!

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

Code d'une ligne:

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

Une façon serait créée un JsonObject et itérer à 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 aide.