JSON che analizza 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 class è:

 public class JsonParsing{ public void parse(String jsonLine) { // there I would like to get String "Hello world" } } 

Questo è un codice semplice 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 javadoc di Gson sono abbastanza chiari e utili.

Nella mia prima applicazione gson ho evitato di usare classi aggiuntive per catturare i valori principalmente perché uso json per questioni di configurazione

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

a partire 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 Gson StringMap)

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 una lista array

Puoi usare questi fatti (combinati) a tuo vantaggio

Finalmente questo è il codice che rende la cosa

  Map 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 eseguire il bind utilizzando GSON, attraversare la gerarchia degli oggetti tramite i campi. Aggiungere getter e setter è inutile per i contenitori di dati di base.

Quindi qualcosa come:

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

È ansible creare classi java corrispondenti per gli oggetti JSON. Il numero intero, i valori stringa 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

È ansible utilizzare una class separata per rappresentare l’object JSON e utilizzare @SerializedName annotazioni @SerializedName per specificare il nome del campo da afferrare per ciascun membro 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 puoi eseguire l’analisi nel tuo metodo parse () usando un object Gson :

 Gson gson = new Gson(); Response response = gson.fromJson(jsonLine, Response.class); System.out.println("Translated text: " + response.getTranslatedText()); 

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

Usare Gson per risolvere
Vorrei creare una class per parametro individuale nella stringa json. In alternativa puoi creare una class principale chiamata “Dati” e quindi creare classi interne allo stesso modo. Ho creato classi separate per chiarezza.

Le classi sono le seguenti.

  • Dati
  • Traduzioni
  • TranslatedText

Nella class JsonParsing il metodo “parse” chiamiamo gson.fromJson(jsonLine, Data.class) che convertirà la stringa in oggetti java usando Reflection.

Una volta che abbiamo accesso all’object “Dati”, possiamo accedere a ciascun parametro individualmente.

Non ho avuto la possibilità di testare questo codice come sono lontano dalla mia macchina dev. 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}

In primo luogo generare Getter e incastonatore utilizzando il sito di analisi sottostante

http://www.jsonschema2pojo.org/

Adesso usa Gson

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

Ora usa l’object per ottenere valori come dati, translationText

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

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

Un codice di linea:

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

Un modo sarebbe creato un JsonObject e iterando attraverso i parametri. Per esempio

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

Quindi puoi 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.