Given the following Json data:
"values": [
{
"type": "any",
"value": "MO918038B",
"key": "nino"
},
{
"type": "any",
"value": "1956-11-18",
"key": "dob"
},
{
"type": "any",
"value": "q",
"key": "memorableWord"
},
{
"type": "any",
"value": "E13468",
"key": "pin"
},
]
And the following Java class:
public void doStuff() {
try (Reader reader = new FileReader("global-vars.json")) {
JsonObject json = new Gson().fromJson(reader, JsonObject.class);
String reg = json.get("values").toString();
System.out.println(reg);
} catch (IOException e) {
e.printStackTrace();
}
}
I'm not clear, after searching, how best to obtain the "value" of, for example, "nino" which is = "MO918038B"
Type listType = new TypeToken<List<YourObjectClass>>() {}.getType();
List<YourObjectClass> yourList = new Gson().fromJson(yourJson, listType);
Since your posted JSON isn't RFC 4627 conformant, I assume this array is inside of an object.
Code would look like this:
public class YourClass {
class Value {
public String type;
public String value;
public String key;
}
public Value[] values;
}
public class App{
public static void main(String[] args) {
String json = "{ \"values\": [\n" +
"{\n" +
" \"type\": \"any\",\n" +
" \"value\": \"MO918038B\",\n" +
" \"key\": \"nino\"\n" +
"},\n" +
"{\n" +
" \"type\": \"any\",\n" +
" \"value\": \"1956-11-18\",\n" +
" \"key\": \"dob\"\n" +
"},\n" +
"{\n" +
" \"type\": \"any\",\n" +
" \"value\": \"q\",\n" +
" \"key\": \"memorableWord\"\n" +
"},\n" +
"{\n" +
" \"type\": \"any\",\n" +
" \"value\": \"E13468\",\n" +
" \"key\": \"pin\"\n" +
"}\n" +
"]}";
YourClass yourClass = new Gson().fromJson(json, YourClass.class);
for (YourClass.Value value : yourClass.values) {
if (value.key.equals("nino")) {
System.out.println(value.value);
}
}
}
}
Related
I have the following method that when receiving an xml in a String converts it to objects of type CitiMarketSSAEvent
public CitiMarketSSAEvent convertXmlToObject(String xml){
CitiMarketSSAEvent citiMarket = null;
JAXBContext jaxbContext = JAXBContext.newInstance(CitiMarketSSAEvent.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
StringReader reader = new StringReader(xml);
citiMarket = (CitiMarketSSAEvent) unmarshaller.unmarshal(reader);
return citiMarket;
}
and then I have the following method that converts the objects of that class into a json
public String convertObjectToJson(CitiMarketSSAEvent citiMarketObject) {
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setPrettyPrinting();
gsonBuilder.disableHtmlEscaping();
Gson gson = gsonBuilder.create();
return gson.toJson(citiMarketObject, CitiMarketSSAEvent.class);
}
and it paints the json as follows
{
"header":{
"name": "transactionCount",
"version": "2.0",
"code": "1530",
"country": "MX",
"domain": "counts",
"time": "2018-10-11 11:20:34.323 GMT",
},
"body":{
"INPUNT": "I",
"MESSAGE_01": "RSTW",
"MESSAGE_02": "MNXTYP",
"MESSAGE_03": "RSTWERDCV",
"SEND_TIME": "20-NOV-2011 04:53:04 p.m.",
"RCV_ID": "ABGRCV",
"FORMAT0_MONTO": "200,000,300.00",
"FORMATO_MONEDA": "USD",
"CONTROL_01": "MSG1RCVSND",
"CONTROL_02": "MSG2RCVSND",
"CONTROL_03": "MSG3RCVSND",
}
}
but I want to add the "event" key to the json in such a way that I get something like this:
{
"event":{
"header":{
"name": "transactionCount",
"version": "2.0",
"code": "1530",
"country": "MX",
"domain": "counts",
"time": "2018-10-11 11:20:34.323 GMT",
},
"body":{
"INPUNT": "I",
"MESSAGE_01": "RSTW",
"MESSAGE_02": "MNXTYP",
"MESSAGE_03": "RSTWERDCV",
"SEND_TIME": "20-NOV-2011 04:53:04 p.m.",
"RCV_ID": "ABGRCV",
"FORMAT0_MONTO": "200,000,300.00",
"FORMATO_MONEDA": "USD",
"CONTROL_01": "MSG1RCVSND",
"CONTROL_02": "MSG2RCVSND",
"CONTROL_03": "MSG3RCVSND",
}
}
}
and then I modified my method as follows using JSONObject
public String convertObjectToJson(CitiMarketSSAEvent citiMarketObject) {
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setPrettyPrinting();
gsonBuilder.disableHtmlEscaping();
JSONObject jsonObj = new JSONObject();
jsonObj.put("event",citiMarketObject);
Gson gson = gsonBuilder.create();
return gson.toJson(jsonObj, JSONObject.class);
}
and it throws me the json but the key "nameValuePairs" was added, how can it be removed? Or how else can I do it to just add the "event" key?
{
"nameValuePairs":{
"event":{
"header":{
"name": "transactionCount",
"version": "2.0",
"code": "1530",
"country": "MX",
"domain": "counts",
"time": "2018-10-11 11:20:34.323 GMT",
},
"body":{
"INPUNT": "I",
"MESSAGE_01": "RSTW",
"MESSAGE_02": "MNXTYP",
"MESSAGE_03": "RSTWERDCV",
"SEND_TIME": "20-NOV-2011 04:53:04 p.m.",
"RCV_ID": "ABGRCV",
"FORMAT0_MONTO": "200,000,300.00",
"FORMATO_MONEDA": "USD",
"CONTROL_01": "MSG1RCVSND",
"CONTROL_02": "MSG2RCVSND",
"CONTROL_03": "MSG3RCVSND",
}
}
}
}
Try this code, it is supposed to do what you need.
package com;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.LinkedHashMap;
public class Main {
public static void main(String[] args) throws JsonProcessingException {
String json = "{\n" +
" \"header\":{\n" +
" \"name\": \"transactionCount\",\n" +
" \"version\": \"2.0\",\n" +
" \"code\": \"1530\",\n" +
" \"country\": \"MX\",\n" +
" \"domain\": \"counts\",\n" +
" \"time\": \"2018-10-11 11:20:34.323 GMT\"\n" +
" },\n" +
" \"body\":{\n" +
" \"INPUNT\": \"I\",\n" +
" \"MESSAGE_01\": \"RSTW\",\n" +
" \"MESSAGE_02\": \"MNXTYP\",\n" +
" \"MESSAGE_03\": \"RSTWERDCV\",\n" +
" \"SEND_TIME\": \"20-NOV-2011 04:53:04 p.m.\",\n" +
" \"RCV_ID\": \"ABGRCV\",\n" +
" \"FORMAT0_MONTO\": \"200,000,300.00\",\n" +
" \"FORMATO_MONEDA\": \"USD\",\n" +
" \"CONTROL_01\": \"MSG1RCVSND\",\n" +
" \"CONTROL_02\": \"MSG2RCVSND\",\n" +
" \"CONTROL_03\": \"MSG3RCVSND\"\n" +
" }\n" +
"}";
ObjectMapper objectMapper = new ObjectMapper();
LinkedHashMap hashMap = objectMapper.readValue(json, LinkedHashMap.class);
Event event = new Event(hashMap);
System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(event));
}
public static class Event {
#JsonProperty("event")
private LinkedHashMap event;
public Event(LinkedHashMap event){
this.event = event;
}
}
}
I am trying to convert the keys in my json string to camelCase..i have gone trough various posts in the stackoverflow but couldn't come to the solution..
i have a json string coming in the below format..
{
"tech":[
{
"id":"1",
"company_name":"Microsoft",
"country_of_origin":"USA"
},
{
"id":"2",
"company_name":"SAP",
"country_of_origin":"Germany"
}
],
"Manufacturing":[
{
"id":"3",
"company_name":"GM",
"country_of_origin":"USA"
},
{
"id":"4",
"company_name":"BMW",
"country_of_origin":"Germany"
}
]
}
Expected Response
{
"tech":[
{
"id":"1",
"companyName":"Microsoft",
"countryOfOrigin":"USA"
},
{
"id":"2",
"companyName":"SAP",
"countryOfOrigin":"Germany"
}
],
"Manufacturing":[
{
"id":"3",
"companyName":"GM",
"countryOfOrigin":"USA"
},
{
"id":"4",
"companyName":"BMW",
"countryOfOrigin":"Germany"
}
]
}
i have written a jsonDeserializer class based on previous post in stackoverflow..
Gson gson = new GsonBuilder()
.registerTypeAdapter(UpperCaseAdapter.TYPE, new UpperCaseAdapter())
.create();
Map<String, List<Company>> mapDeserialized = gson.fromJson(jsonString, UpperCaseAdapter.TYPE);
System.out.println(mapDeserialized);
And the deserilizer
public class UpperCaseAdapter implements JsonDeserializer<Map<String, Object>> {
public static final Type TYPE = new TypeToken<Map<String, Object>>() {}.getType();
#Override
public Map<String, Object> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
Map<String, Object> map = new HashMap<>();
for (Map.Entry<String, JsonElement> entry : json.getAsJsonObject().entrySet()) {
Object value = null;
if (entry.getValue().isJsonPrimitive()) {
value = entry.getValue().getAsString();
} else if (entry.getValue().isJsonObject()) {
value = context.deserialize(entry.getValue(), TYPE);
} else if (entry.getValue().isJsonArray()) {
for(JsonElement jsonElement:entry.getValue().getAsJsonArray()){
value=context.deserialize(jsonElement,TYPE);
}
} else if (entry.getValue().isJsonNull()) {
continue;
}
map.put(CaseFormat.LOWER_UNDERSCORE.to(
CaseFormat.LOWER_CAMEL, entry.getKey()), value);
}
return map;
}
}
Model class
public class Company {
private String id;
private String compnayName;
private String countryOfOrigin;
}
When i use the above deserilizer though it is able to convert the keys to camle case for some json array object....i can see that it is only doing that for one jsonobject in each array and not taking other array objects in to consideration.as shown below.
Wrong Response i am getting with above serializer(missing other jsonobjecsts and the key manufacturing is converted to lower):
{
"tech="{
"companyName=SAP",
id=2,
"countryOfOrigin=Germany"
},
"manufacturing="{
"companyName=BMW",
id=4,
"countryOfOrigin=Germany"
}
}
I know there are lot of posts available in stackoverflow and i have to this extent solely based on those posts but as i am new to Java and json serilization i couldn't progress anymore...any help in this regard is greatly appreciated thanks in advance
you can use the following code to get the CamelCase string;
static public class Company {
private String id;
private String companyName;
private String countryOfOrigin;
public Company() {
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public String getCountryOfOrigin() {
return countryOfOrigin;
}
public void setCountryOfOrigin(String countryOfOrigin) {
this.countryOfOrigin = countryOfOrigin;
}
}
#Test
void t4() throws JsonProcessingException {
ObjectMapper mapperSC = new ObjectMapper();
mapperSC.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.LOWER_CAMEL_CASE);
String data = "{ " +
" \"tech\":[ " +
" { " +
" \"id\":\"1\", " +
" \"company_name\":\"Microsoft\", " +
" \"country_of_origin\":\"USA\" " +
" }, " +
" { " +
" \"id\":\"2\", " +
" \"company_name\":\"SAP\", " +
" \"country_of_origin\":\"Germany\" " +
" } " +
" ], " +
" \"Manufacturing\":[ " +
" { " +
" \"id\":\"3\", " +
" \"company_name\":\"GM\", " +
" \"country_of_origin\":\"USA\" " +
" }, " +
" { " +
" \"id\":\"4\", " +
" \"company_name\":\"BMW\", " +
" \"country_of_origin\":\"Germany\" " +
" } " +
" ] " +
"}";
TypeFactory tf = mapper.getTypeFactory();
JavaType jt = tf.constructMapType(Map.class, tf.constructType(String.class), tf.constructArrayType(Company.class));
Object o = mapperSC.readValue(data, jt);
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(o));
}
The output will be;
{
"tech" : [ {
"id" : "1",
"companyName" : "Microsoft",
"countryOfOrigin" : "USA"
}, {
"id" : "2",
"companyName" : "SAP",
"countryOfOrigin" : "Germany"
} ],
"Manufacturing" : [ {
"id" : "3",
"companyName" : "GM",
"countryOfOrigin" : "USA"
}, {
"id" : "4",
"companyName" : "BMW",
"countryOfOrigin" : "Germany"
} ]
}
All,
I have following JSON response after request get list of users. I want to pull just only one user's id using userName. For example if i want id of userName Test1, how to do that? Any help will be appreciated.
{
"displayLength": "4",
"iTotal": "20",
"users": [
{
"id": "2",
"userName": "Test1",
"Group": { id:1
name:"Test-Admin"
}
},
{
"id": "17",
"userName": "Test2",
"Group": { id:1
name:"Test-Admin"
}
},
{
"id": "32",
"userName": "Test3",
"Group": { id:1
name:"Test-Admin"
}
},
{
"id": "35",
"userName": "Test4",
"Group": { id:1
name:"Test-Admin"
}
}
]
}
Thanks,
See if this below code helps. Just pass user name to userName variable and let the code find the userId for you.
JSONObject json = new JSONObject(" {\n" + " \"displayLength\": \"4\",\n"
+ " \"iTotal\": \"20\",\n" + " \"users\": [\n" + " {\n"
+ " \"id\": \"2\",\n" + " \"userName\": \"Test1\",\n"
+ " \"Group\": { id:1,\n" + " name:\"Test-Admin\"\n"
+ " }\n" + " },\n" + " {\n" + " \"id\": \"17\",\n"
+ " \"userName\": \"Test2\",\n" + " \"Group\": { id:1,\n"
+ " name:\"Test-Admin\"\n" + " }\n" + " },\n"
+ " {\n" + " \"id\": \"32\",\n" + " \"userName\": \"Test3\",\n"
+ " \"Group\": { id:1,\n" + " name:\"Test-Admin\"\n"
+ " }\n" + " },\n" + " {\n" + " \"id\": \"35\",\n"
+ " \"userName\": \"Test4\",\n" + " \"Group\": { id:1,\n"
+ " name:\"Test-Admin\"\n" + " }\n" + " } \n"
+ "\n" + " ]\n" + " }");
JSONArray array = json.getJSONArray("users");
String userName = "Test1";
Integer userId = null;
for (int i = 0; i < array.length() && userId == null; i++) {
JSONObject jsonIn = (JSONObject) array.get(i);
if (jsonIn.optString("userName").equals(userName)) {
userId = jsonIn.optInt("id");
}
}
System.out.println("User ID for User Name '" + userName + "' is : " + userId);
I recomend use http-request built on apache http api. You must create class ResponseData to parse response.
private static final HttpRequest<ResponseData> HTTP_REQUEST =
HttpRequestBuilder.createGet(yourUri, ResponseData.class).build();
public void test() {
HTTP_REQUEST.execute().ifHasContent(responseData -> {
Optional<User> foundedUser = responseData.getUsers()
.stream()
.filter(user -> "Test1".equals(user.getUserName()))
.findFirst();
foundedUser.ifPresent(user -> System.out.println(user.getId()));
});
}
class ResponseData {
private int displayLength;
private int iTotal;
private List<User> users;
public int getDisplayLength() {
return displayLength;
}
public void setDisplayLength(int displayLength) {
this.displayLength = displayLength;
}
public int getiTotal() {
return iTotal;
}
public void setiTotal(int iTotal) {
this.iTotal = iTotal;
}
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
}
class User {
private int id;
private String userName;
private Group Group;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Group getGroup() {
return Group;
}
public void setGroup(Group group) {
Group = group;
}
}
class Group {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Note: Your json is incorrect. See Corrected:
{
"displayLength": "4",
"iTotal": "20",
"users": [
{
"id": "2",
"userName": "Test1",
"Group": {
"id": 1,
"name": "Test-Admin"
}
},
{
"id": "17",
"userName": "Test2",
"Group": {
"id": 1,
"name": "Test-Admin"
}
},
{
"id": "32",
"userName": "Test3",
"Group": {
"id": 1,
"name": "Test-Admin"
}
},
{
"id": "35",
"userName": "Test4",
"Group": {
"id": 1,
"name": "Test-Admin"
}
}
]
}
jsonObj.getJsonArray("users") and then convert the array to list. Now use Java 8 Stream and Filter api's to extract the desired output.
I have following json data:-
{
"store": {
"book": [
{
"category": "reference",
"author": "Nigel Rees",
"title": "Sayings of the Century",
"price": 8.95
},
{
"category": "fiction",
"author": "Evelyn Waugh",
"title": "Sword of Honour",
"price": 12.99
},
{
"category": "fiction",
"author": "Herman Melville",
"title": "Moby Dick",
"isbn": "0-553-21311-3",
"price": 8.99
},
{
"category": "fiction",
"author": "J. R. R. Tolkien",
"title": "The Lord of the Rings",
"isbn": "0-395-19395-8",
"price": 22.99
}
],
"bicycle": {
"color": "red",
"price": 19.95
}
},
"expensive": 10
}
Method to assert json:-
public void assertJsonvalue (String description, String jsonString,
String path, Object expectedValue) {
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> jsonMap = null;
try {
jsonMap = objectMapper.readValue(jsonString,
new TypeReference<Map<String, Object>>() {
});
} catch (IOException e) {
fail("Could not parse json from string:" + jsonString);
}
Object actualValue = null;
try {
actualValue = PropertyUtils.getProperty(jsonMap, path);
System.out.println("actualValue" + actualValue);
} catch (IllegalAccessException e) {
// error here
}
assertEquals(description, expectedValue, actualValue);
}
When I try to get json value from by using the following, Its works well.
assertJsonValue("bicycle color", json, "store.bicycle.color", "red");
I want to get array value from json such as details of 1st book.
I have tried the following, that doesn't help me out.
json paths are as follows:-
"store.book[0]"
"store.book.[0]"
"store.book.category"
How Can I do this ?
According to this answer, you should be able to get the mentioned properties like this:
assertJsonValue("...", json, "store.(book)[0].category", "reference");
Edit:
Which version of jackson and beanutils are you using? I've modified your method a bit and made a simple test case, using beanutils 1.9.2 and jackson 2.6.5 tests seem to pass:
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.Test;
import java.io.IOException;
import static org.junit.Assert.*;
public class TestJson {
private static final String JSON = "{\n" +
" \"store\": {\n" +
" \"book\": [\n" +
" {\n" +
" \"category\": \"reference\",\n" +
" \"author\": \"Nigel Rees\",\n" +
" \"title\": \"Sayings of the Century\",\n" +
" \"price\": 8.95\n" +
" }\n" +
" ],\n" +
" \"bicycle\": {\n" +
" \"color\": \"red\",\n" +
" \"price\": 19.95\n" +
" }\n" +
" },\n" +
" \"expensive\": 10\n" +
"}";
#Test
public void testJson() {
assertTrue(assertJsonValue(JSON, "store.(book)[0].category", "reference"));
assertTrue(assertJsonValue(JSON, "store.(book)[0].author", "Nigel Rees"));
assertTrue(assertJsonValue(JSON, "store.(book)[0].title", "Sayings of the Century"));
assertTrue(assertJsonValue(JSON, "store.(book)[0].price", 8.95));
}
public boolean assertJsonValue(String jsonString,
String path,
Object expectedValue) {
ObjectMapper objectMapper = new ObjectMapper();
try {
Object actual = PropertyUtils
.getProperty(objectMapper.readValue(jsonString, Object.class), path);
if (actual.equals(expectedValue)) {
return true;
}
} catch (IOException | ReflectiveOperationException e) {
// handle error
}
return false;
}
}
I am using google's GSON parsing library and I'm not sure if this has been asked before (I did check what I could find) but, here I go!! It's regarding the fromJSON method and how it refuses to interpret some classes as arrays.
Given the JSON structure below:
{"visualization": {
"root": {
"fullname": "CC/dudu",
"name": "dudu",
"type": "String",
"children": [
{
"fullname": "CC/dudu/lulu",
"name": "lulu",
"type": "String"
}
]
},
"traces": {
"messages": [
{
"from": "dudu",
"method": "call()",
"scenario": "#1",
"timestamp": "09-12-2013 00:21:14",
"to": "dudu",
"type": "void",
"violation": "true",
"visible": "true"
}
],
"scenarios": [
{
"name": "testscenario",
"id": "#1",
"description": "testing parsing!"
}
]
}
}}
And the accompanying contained classes.
public class Response {
private Visualization visualization;
//+getter/setter
}
public class Visualization {
private Component root;
private Map<String, Trace> traces;
//+getter/setter
}
public class Trace {
private ArrayList<Message> messages;
private ArrayList<Scenario> scenarios;
//+getter/setter
}
I get the error that GSON was expecting an Object and NOT an Array (before the "[" token of messages). Anyone know why that is? The types (as can be seen in the classes) are List, so it should be fine. And I have tried having more objects in the array and I still get the same error message! Why is Gson interpreting the List<TypeA> type as an object and not an array?
EDIT:
Here's the code code, but it's kinda pointless, since the exception is being thrown because of the parsing process. I doubt you'll find anything useful. "visualization" is a string with a correct JSON format.
Gson gsonParser = new Gson();
Response r = gsonParser.fromJson(visualization, Response.class);
The code below allows you to parse exactly your JSON.
Note that I put all into a class to make easier for you to test it. Anycase, Gson does not work well with inner classes unless they are static. So I suggest you to make a file for each class or use only static inner classes.
package stackoverflow.questions;
import java.util.*;
import com.google.gson.Gson;
public class Q20461706 {
public class Trace {
ArrayList<Message> messages;
ArrayList<Scenario> scenarios;
#Override
public String toString() {
return "Trace [messages=" + messages + ", scenarios=" + scenarios + "]";
}
}
public static class Message {
String from; // "from": "dudu",
String method; // "method": "call()",
String scenario; // "scenario": "#1",
String timestamp; // "timestamp": "09-12-2013 00:21:14",
String to; // "to": "dudu",
String type; // "type": "void",
Boolean violation; // "violation": "true",
Boolean visible; // "visible": "true"
#Override
public String toString() {
return "Message [from=" + from + ", method=" + method + ", scenario=" + scenario + ", timestamp=" + timestamp + ", to=" + to + ", type=" + type + ", violation=" + violation + ", visible=" + visible + "]";
}
}
public static class Scenario {
String name;// "name": "testscenario",
String id; // "id": "#1",
String description; // "description": "testing parsing!"
#Override
public String toString() {
return "Scenario [name=" + name + ", id=" + id + ", description=" + description + "]";
}
}
public static class Component {
String fullname; // "fullname": "CC/dudu",
String name; // "name": "dudu",
String type; // "type": "String",
List<Component> children;
#Override
public String toString() {
return "Component [fullname=" + fullname + ", name=" + name + ", type=" + type + ", children=" + children + "]";
}
}
public static class Visualization {
Component root;
Trace traces;
#Override
public String toString() {
return "Visualization [root=" + root + ", traces=" + traces + "]";
}
}
public static class Response {
Visualization visualization;
#Override
public String toString() {
return "Response [visualization=" + visualization + "]";
}
}
public static void main(String[] args) {
String json =
" {\"visualization\": { "+
" \"root\": { "+
" \"fullname\": \"CC/dudu\", "+
" \"name\": \"dudu\", "+
" \"type\": \"String\", "+
" \"children\": [ "+
" { "+
" \"fullname\": \"CC/dudu/lulu\", "+
" \"name\": \"lulu\", "+
" \"type\": \"String\" "+
" } "+
" ] "+
" }, "+
" \"traces\": { "+
" \"messages\": [ "+
" { "+
" \"from\": \"dudu\", "+
" \"method\": \"call()\", "+
" \"scenario\": \"#1\", "+
" \"timestamp\": \"09-12-2013 00:21:14\", "+
" \"to\": \"dudu\", "+
" \"type\": \"void\", "+
" \"violation\": \"true\", "+
" \"visible\": \"true\" "+
" } "+
" ], "+
" \"scenarios\": [ "+
" { "+
" \"name\": \"testscenario\", "+
" \"id\": \"#1\", "+
" \"description\": \"testing parsing!\" "+
" } "+
" ] "+
" } "+
" }} ";
Gson gsonParser = new Gson();
Response r = gsonParser.fromJson(json, Response.class);
System.out.println(r);
}
}
To respond to your question, note that I changed your Visualization class with Trace traces since you have only a Trace object in your JSON and not an array. This is why Gson complains.
Note also that I avoided to parse the date as date, you need to specify a custom date format for that, but it's beyond the scope of this question. You can find many examples here on SO.