This is simple code to do it, I avoided all checks but this is the main idea.
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;
}
To make the use more generic - you will find that Gson's javadocs are pretty clear and helpful.
In my first gson application I avoided using additional classes to catch values mainly because I use json for config matters
despite the lack of information (even gson page), that's what I found and used:
starting from
Map jsonJavaRootObject = new Gson().fromJson("{/*whatever your mega complex object*/}", Map.class)
Each time gson sees a {}, it creates a Map (actually a gson StringMap )
Each time gson sees a '', it creates a String
Each time gson sees a number, it creates a Double
Each time gson sees a [], it creates an ArrayList
You can use this facts (combined) to your advantage
Finally this is the code that makes the thing
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")
);
Simplest thing usually is to create matching Object hierarchy, like so:
public class Wrapper {
public Data data;
}
static class Data {
public Translation[] translations;
}
static class Translation {
public String translatedText;
}
and then bind using GSON, traverse object hierarchy via fields. Adding getters and setters is pointless for basic data containers.
So something like:
Wrapper value = GSON.fromJSON(jsonString, Wrapper.class);
String text = value.data.translations[0].translatedText;
You can create corresponding java classes for the json objects. The integer, string values can be mapped as is. Json can be parsed like this-
Gson gson = new GsonBuilder().create();
Response r = gson.fromJson(jsonString, Response.class);
Here is an example- http://rowsandcolumns.blogspot.com/2013/02/url-encode-http-get-solr-request-and.html
You can use a separate class to represent the JSON object and use @SerializedName
annotations to specify the field name to grab for each data member:
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;
}
}
Then you can do the parsing in your parse() method using a Gson
object:
Gson gson = new Gson();
Response response = gson.fromJson(jsonLine, Response.class);
System.out.println("Translated text: " + response.getTranslatedText());
With this approach, you can reuse the Response
class to add any other additional fields to pick up other data members you might want to extract from JSON -- in case you want to make changes to get results for, say, multiple translations in one call, or to get an additional string for the detected source language.
One way would be created a JsonObject and iterating through the parameters. For example
JsonObject jobj = new Gson().fromJson(jsonString, JsonObject.class);
Then you can extract bean values like:
String fieldValue = jobj.get(fieldName).getAsString();
boolean fieldValue = jobj.get(fieldName).getAsBoolean();
int fieldValue = jobj.get(fieldName).getAsInt();
Hope this helps.
Using Gson to Solve
I would create a class for individual parameter in the json String. Alternatively you can create one main class called "Data" and then create inner classes similarly. I created separate classes for clarity.
The classes are as follows.
In the class JsonParsing the method "parse" we call gson.fromJson(jsonLine, Data.class)
which will convert the String in java objects using Reflection.
Once we have access to the "Data" object we can access each parameter individually.
Didn't get a chance to test this code as I am away from my dev machine. But this should help.
Some good examples and 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;
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With