Analisi JSON utilizzando Gson per Java

Vorrei analizzare i dati da JSON che è di tipo String. Sto usando Google Gson .

Io ho:

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

e la mia classe è:

public class JsonParsing{

   public void parse(String jsonLine) {

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

   }

}

Questo è un semplice codice per farlo, ho evitato tutti i controlli ma questa è l'idea 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;
}

Per rendere l'uso più generico, scoprirai che i javadocs di Gson sono piuttosto chiari e utili.

Nella mia prima applicazione gson ho evitato di utilizzare classi aggiuntive per rilevare i valori principalmente perché utilizzo json per questioni di configurazione

nonostante la mancanza di informazioni (anche pagina gson), è quello che ho trovato e usato:

partendo da

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

Ogni volta che gson vede un {}, crea una mappa (in realtà una StringMap gson)

Ogni volta che gson vede un '', crea una stringa

Ogni volta che gson vede un numero, crea un doppio

Ogni volta che gson vede un [], crea un ArrayList

È possibile utilizzare questi fatti (combinati) a proprio vantaggio

Finalmente questo è il codice che rende la cosa

        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 cosa più semplice di solito è creare una gerarchia di oggetti corrispondente, in questo modo:

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

e quindi associare utilizzando GSON, attraversare la gerarchia degli oggetti tramite i campi. L'aggiunta di getter e setter non ha senso per i contenitori di dati di base.

Quindi qualcosa come:

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

È possibile creare classi java corrispondenti per gli oggetti json. I valori di stringa interi, possono essere mappati così come sono. Json può essere analizzato in questo modo-

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

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

È possibile utilizzare una classe separata per rappresentare l'oggetto JSON e utilizzare le @SerializedNameannotazioni per specificare il nome del campo da acquisire per ciascun membro di dati:

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

Quindi è possibile eseguire l'analisi nel metodo parse () utilizzando un Gsonoggetto:

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

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

Con questo approccio, puoi riutilizzare la Responseclasse per aggiungere altri campi aggiuntivi per raccogliere altri membri di dati che potresti voler estrarre da JSON. Nel caso in cui desideri apportare modifiche per ottenere risultati, ad esempio, per più traduzioni in una chiamata, o per ottenere una stringa aggiuntiva per la lingua di origine rilevata.

In un modo sarebbe stato creato un oggetto Json e ripetendo i parametri. Per esempio

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

Quindi è possibile estrarre valori di bean come:

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

Spero che questo ti aiuti.

Usando Gson per risolvere
vorrei creare una classe per singolo parametro nella stringa json. In alternativa è possibile creare una classe principale denominata "Dati" e quindi creare classi interne in modo simile. Ho creato classi separate per chiarezza.

Le lezioni sono le seguenti.

• Dati
• Traduzioni
• TranslatedText

Nella classe JsonParsing viene chiamato il metodo "parse" gson.fromJson(jsonLine, Data.class)che convertirà la stringa in oggetti java usando Reflection.

Una volta che abbiamo accesso all'oggetto "Dati" possiamo accedere a ciascun parametro singolarmente.

Non ho avuto la possibilità di testare questo codice perché sono lontano dalla mia macchina di sviluppo. Ma questo dovrebbe aiutare.

Alcuni buoni esempi e articoli.
http://albertattard.blogspot.com/2009/06/practical-example-of-gson.html
http://sites.google.com/site/gson/gson-user-guide

Codice

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 semplice esempio per analizzare un JSON come questo

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

Generare innanzitutto Getter e Setter utilizzando il sito di analisi sottostante

http://www.jsonschema2pojo.org/

Ora usa Gson

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

Ora usa l'oggetto per ottenere valori come data, translationText

È possibile utilizzare una query JsonPath per estrarre il valore. E con JsonSurfer, che è supportato da Gson, il tuo problema può essere risolto semplicemente con due righe di codice!

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

Codice di una riga:

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