考虑引入gson，测试整理了工具类：
对于List，Map的泛型解析，借鉴：
http://www.blogjava.net/brock/archive/2012/08/01/384520.html
http://www.cnblogs.com/qq78292959/p/3781808.html
public class JsonUtils {
public static String toJson(Object arg) {
Gson gson = new Gson();
return gson.toJson(arg);
}
public static <T> T getObjectFromJson(String json, Class<T> classOfT) {
Gson gson = new Gson();
return gson.fromJson(json, classOfT);
}
public static <T> List<T> getListFromJson(String json, Class<T> classOfT) {
Gson gson = new Gson();
Type type = type(List.class, classOfT);
return gson.fromJson(json, type);
// return gson.fromJson(json, new TypeToken<List<T>>(){}.getType()); 错误
}
public static <K, V, T> Map<K, V> getMapFromJson(String json,
Class<K> classOfK, Class<V> classOfV) {
Gson gson = new Gson();
Type type = type(Map.class, classOfK, classOfV);
return gson.fromJson(json, type);
// return gson.fromJson(json, new TypeToken<Map<K, V>>() {}.getType()); 错误，V类型不能正确解析
}
@SuppressWarnings("rawtypes")
public static ParameterizedType type(final Class raw, final Type... args) {
return new ParameterizedType() {
public Type getRawType() {
return raw;
}
public Type[] getActualTypeArguments() {
return args;
}
public Type getOwnerType() {
return null;
}
};
}
public static void main(String[] args) {
Map<String, Object> map1 = new HashMap<String, Object>();
Map<String, Object> subMap1 = new HashMap<String, Object>();
map1.put("mapa1", 1);
map1.put("mapb1", 2);
map1.put("mapc1", new Date());
subMap1.put("sub_a1", 1);
subMap1.put("sub_b1", 2);
map1.put("subMap1", subMap1);
System.out.println(JsonUtils.toJson(map1));
Map<String, Object> map2 = new HashMap<String, Object>();
Map<String, Object> subMap2 = new HashMap<String, Object>();
map2.put("mapa2", 1);
map2.put("mapb2", 2);
map2.put("mapc2", new Date());
subMap2.put("sub_a2", 1);
subMap2.put("sub_b2", 2);
map2.put("subMap2", subMap2);
B b1 = new B("b1", "b1name", map1);
B b2 = new B("b2", "b2name", map2);
List<B> bList1 = Arrays.asList(new B[] { b1, b2 });
A a1 = new A("a1", "a1name", bList1);
System.out.println(JsonUtils.toJson(a1));
B b3 = new B("b3", "b3name", map1);
B b4 = new B("b4", "b4name", map2);
List<B> bList2 = Arrays.asList(new B[] { b3, b4 });
A a2 = new A("a2", "a2name", bList2);
List<A> aList1 = Arrays.asList(new A[] { a1, a2 });
System.out.println("aList1-json:" + JsonUtils.toJson(aList1));
System.out.println("bList1-json:" + JsonUtils.toJson(bList1));
System.out.println("map2-json:" + JsonUtils.toJson(map2));
String json = "{\"id\":\"a1\",\"name\":\"a1name\",\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 15, 2014 3:07:56 PM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 15, 2014 3:07:56 PM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}";
A jsonA1 = JsonUtils.getObjectFromJson(json, A.class);
System.out.println(jsonA1.getId() + "--" + jsonA1.getName());
List<B> jsonbList1 = jsonA1.getbList();
for (B jsonb1 : jsonbList1) {
System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
Map<String, Object> jsonbMap1 = jsonb1.getVariable();
Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
for (Entry<String, Object> entry : entrySet) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
}
System.out.println("*********************************************");
String aList1Json = "[{\"id\":\"a1\",\"name\":\"a1name\",\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 18, 2014 10:42:19 AM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 18, 2014 10:42:19 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]},{\"id\":\"a2\",\"name\":\"a2name\",\"bList\":[{\"id\":\"b3\",\"name\":\"b3name\",\"variable\":{\"mapc1\":\"Aug 18, 2014 10:42:19 AM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b4\",\"name\":\"b4name\",\"variable\":{\"mapc2\":\"Aug 18, 2014 10:42:19 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}, {\"id\":\"a1\",\"name\":\"a1name\",\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 18, 2014 10:42:19 AM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 18, 2014 10:42:19 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]},{\"id\":\"a2\",\"name\":\"a2name\",\"bList\":[{\"id\":\"b3\",\"name\":\"b3name\",\"variable\":{\"mapc1\":\"Aug 18, 2014 10:42:19 AM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b4\",\"name\":\"b4name\",\"variable\":{\"mapc2\":\"Aug 18, 2014 10:42:19 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}]";
List<A> aJsonList1 = JsonUtils.getListFromJson(aList1Json, A.class);
int i=0;
for (A jsona1 : aJsonList1) {
System.out.println(i++ + "--" + jsona1.getId() + "--" + jsona1.getName());
List<B> a1jsonbList1 = jsona1.getbList();
for (B jsonb1 : a1jsonbList1) {
System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
Map<String, Object> jsonbMap1 = jsonb1.getVariable();
Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
for (Entry<String, Object> entry : entrySet) {
String key = entry.getKey();
Object value = entry.getValue();
if (key.equalsIgnoreCase("subMap1") || key.equalsIgnoreCase("subMap2")){
Map<String, Object> jsonSubMap = (Map<String, Object>)value;
Set<Entry<String, Object>> subMapEntrySet = jsonSubMap.entrySet();
for (Entry<String, Object> subMapEntry : subMapEntrySet) {
System.out.println("submap:"+subMapEntry.getKey() + "--" + subMapEntry.getValue());
}
} else {
System.out.println(key + "--" + value);
}
}
}
}
String bList1Json = "[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 15, 2014 4:05:30 PM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 15, 2014 4:05:30 PM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]";
System.out.println("=============================================");
List<B> bJsonList1 = JsonUtils.getListFromJson(bList1Json, B.class);
for (B jsonb1 : bJsonList1) {
System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
Map<String, Object> jsonbMap1 = jsonb1.getVariable();
Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
for (Entry<String, Object> entry : entrySet) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
}
String map2JsonA = "{\"a1\":{\"id\":\"a1\",\"name\":\"a1name\",\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 18, 2014 10:42:19 AM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 18, 2014 10:42:19 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}, \"a2\":{\"id\":\"a1\",\"name\":\"a1name\"}}";
System.out.println("++++++++++++++++++++map嵌套list，定义类对应map，才能正确解析list++++++++++++++++++++++++");
Map<String, A> map2FromJsonA = JsonUtils.getMapFromJson(map2JsonA, String.class, A.class);
Set<Entry<String, A>> map2EntrySetA = map2FromJsonA.entrySet();
for (Entry<String, A> entry : map2EntrySetA) {
A a = entry.getValue();
System.out.println(entry.getKey() + "--" + a.getId() + "--" + a.getName());
List<B> map2JsonAbList = a.getbList();
if (map2JsonAbList != null) {
for (B jsonb1 : map2JsonAbList) {
System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
Map<String, Object> jsonbMap1 = jsonb1.getVariable();
Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
for (Entry<String, Object> entryb : entrySet) {
System.out.println(entryb.getKey() + "--" + entryb.getValue());
}
}
}
}
String map2Json = "{\"mapc2\":\"Aug 18, 2014 10:20:46 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2,\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 15, 2014 3:07:56 PM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 15, 2014 3:07:56 PM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}";
System.out.println("------------------map嵌套list，定义类对应map，才能正确解析list---------------------------");
C c = JsonUtils.getObjectFromJson(map2Json, C.class);
// Map<String, Object> map2FromJson = JsonUtils.getMapFromJson(map2Json, String.class, Object.class);
// Set<Entry<String, Object>> map2EntrySet = map2FromJson.entrySet();
// for (Entry<String, Object> entry : map2EntrySet) {
// System.out.println(entry.getKey() + "--" + entry.getValue());
// }
Map<String, Integer> subMap2FromJson = c.getSubMap2();
Set<Entry<String, Integer>> subMap2EntrySet = subMap2FromJson.entrySet();
for (Entry<String, Integer> entry : subMap2EntrySet) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
List<B> map2JsonbList1 = c.getbList();
for (B jsonb1 : map2JsonbList1) {
System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
Map<String, Object> jsonbMap1 = jsonb1.getVariable();
Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
for (Entry<String, Object> entry : entrySet) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
}
map2Json = "{\"mapc2\":\"Aug 18, 2014 10:20:46 AM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2,\"bList\":[{\"id\":\"b1\",\"name\":\"b1name\",\"variable\":{\"mapc1\":\"Aug 15, 2014 3:07:56 PM\",\"mapb1\":2,\"subMap1\":{\"sub_b1\":2,\"sub_a1\":1},\"mapa1\":1}},{\"id\":\"b2\",\"name\":\"b2name\",\"variable\":{\"mapc2\":\"Aug 15, 2014 3:07:56 PM\",\"subMap2\":{\"sub_b2\":2,\"sub_a2\":1},\"mapa2\":1,\"mapb2\":2}}]}";
System.out.println("---------------------------------------------");
Map<String, Object> map2FromJson = JsonUtils.getMapFromJson(map2Json, String.class, Object.class);
Set<Entry<String, Object>> map2EntrySet = map2FromJson.entrySet();
for (Entry<String, Object> entry : map2EntrySet) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
Map<String, Object> subMap2FromJson2 = (Map<String, Object>)map2FromJson.get("subMap2");
Set<Entry<String, Object>> subMap2EntrySet2 = subMap2FromJson2.entrySet();
for (Entry<String, Object> entry : subMap2EntrySet2) {
System.out.println(entry.getKey() + "--" + entry.getValue());
}
// Map<String, B> map2FromJson2 = JsonUtils.getMapFromJson(map2Json, String.class, B.class);
// List<B> map2bListFromJson = (List<B>)map2FromJson2.get("bList");
// for (B jsonb1 : map2bListFromJson) {
// System.out.println(jsonb1.getId() + "--" + jsonb1.getName());
// Map<String, Object> jsonbMap1 = jsonb1.getVariable();
// Set<Entry<String, Object>> entrySet = jsonbMap1.entrySet();
// for (Entry<String, Object> entry : entrySet) {
// System.out.println(entry.getKey() + "--" + entry.getValue());
// }
// }
}
static class C {
private Date mapc2;
private Map<String, Integer> subMap2;
private Integer mapa2;
private Integer mapb2;
private List<B> bList;
public Date getMapc2() {
return mapc2;
}
public void setMapc2(Date mapc2) {
this.mapc2 = mapc2;
}
public Map<String, Integer> getSubMap2() {
return subMap2;
}
public void setSubMap2(Map<String, Integer> subMap2) {
this.subMap2 = subMap2;
}
public Integer getMapa2() {
return mapa2;
}
public void setMapa2(Integer mapa2) {
this.mapa2 = mapa2;
}
public Integer getMapb2() {
return mapb2;
}
public void setMapb2(Integer mapb2) {
this.mapb2 = mapb2;
}
public List<B> getbList() {
return bList;
}
public void setbList(List<B> bList) {
this.bList = bList;
}
}
static class A {
private String id;
private String name;
private List<B> bList;
public A() {
}
public A(String id, String name, List<B> bList) {
this.id = id;
this.name = name;
this.bList = bList;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<B> getbList() {
return bList;
}
public void setbList(List<B> bList) {
this.bList = bList;
}
}
static class B {
private String id;
private String name;
private Map<String, Object> variable;
public B() {
}
public B(String id, String name, Map<String, Object> variable) {
this.id = id;
this.name = name;
this.variable = variable;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, Object> getVariable() {
return variable;
}
public void setVariable(Map<String, Object> variable) {
this.variable = variable;
}
}
}
对于List，Map的泛型解析，借鉴：
http://www.blogjava.net/brock/archive/2012/08/01/384520.html
http://www.cnblogs.com/qq78292959/p/3781808.html
分享到：
发表评论
相关推荐
本文将深入探讨如何封装一个Gson解析工具类，以优雅地处理JSON数据，尤其是避免在解析过程中遇到`String`为`null`时产生的错误。 首先，我们需要引入Gson库。如果你的项目是Maven项目，可以在pom.xml文件中添加以下...
基于Gson的解析工具类。有解析成对象或集合等多个方法。
请需要的小伙伴下载下来吧，非常好用，一点问题都没有 不了解的朋友，请看关于gson的使用吧，很简单
Gson包工具类是Google开发的一个Java库，用于在Java对象和JSON数据之间进行映射。这个库使得在Java应用程序中处理JSON变得极其便捷，无论是在Android开发还是普通的Java项目中，Gson都是一个非常实用的工具。JSON...
【Gson解析JSON数据】 Gson是Google提供的一款强大的Java库，用于在Java对象和JSON数据之间进行映射。它可以将任何Java对象转换为它的JSON表示形式，反之亦然。在处理JSON数据时，我们经常遇到两种常见的数据结构：...
要使用Gson解析JSON文件，首先需要在项目中引入Gson库。如果你的项目是Maven项目，可以在pom.xml文件中添加以下依赖： ```xml <groupId>com.google.code.gson</groupId> <artifactId>gson <version>2.8.6 ``` ...
本篇文章将详细介绍如何在Android Studio环境下使用Google Gson解析Json数据。 首先，我们需要在项目中引入Gson库。打开build.gradle模块文件，并在dependencies块中添加以下依赖： ```groovy dependencies { ...
这个"Android Gson解析案例"可能包含了如何在Android应用中使用Gson进行基本和高级的JSON操作的示例代码，帮助开发者更好地理解和掌握这一强大的工具。通过学习和实践这些案例，开发者能够提升自己的Android应用开发...
5. **服务端代码**：在描述中提到的`MyeclipseService`可能是服务端提供的接口，它可能包含了接收请求、处理数据（如使用Gson解析或生成JSON）以及返回响应的功能。服务端通常会使用HTTP协议与客户端交互，通过...
本文将深入探讨如何使用Gson解析嵌套的JSON数据。 首先，我们需要了解JSON的基本结构。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它基于JavaScript的一个子集。一个JSON对象以大括号{}包围，...
在Java编程中，Gson库是一个非常常用的工具，它由Google提供，用于在Java对象和JSON数据之间进行互相转换。本文将深入探讨如何使用Gson处理泛型，并将其转换为JSON字符串。 首先，理解泛型在Java中的作用是至关重要...
这个“Gson解析JSON数据的入门级源码”应该包含了一些基础示例，帮助初学者理解如何使用Gson进行JSON操作。现在，我们将深入探讨Gson库的关键特性和使用方法。 **Gson库的引入** 首先，要使用Gson，你需要在项目中...
这个“Google Gson解析Json数据应用实例”旨在深入探讨Gson库的使用，帮助开发者更好地理解和运用它来处理JSON数据。 JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也...
例如，使用OkHttp发送网络请求，然后在回调中使用Gson解析响应数据： ```java OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("http://example.com/api") .build(); ...
Gson提供了`JsonParser`和`JsonElement`等类来解析复杂的JSON结构。例如，如果你有一个包含嵌套JSON的字符串，你可以这样解析： ```java JsonParser parser = new JsonParser(); JsonElement jsonElement = parser....
在Java开发中，Gson库是一个非常常用的工具，它由Google提供，用于在Java对象和JSON数据之间进行互相转换。Gson库的强大之处在于它的灵活性和便捷性，使得处理JSON格式的数据变得简单易行。本测试类将深入探讨如何...
总的来说，Gson库是Java开发者处理JSON数据的强大工具，其简洁的API和高效的性能使得JSON序列化和反序列化变得非常简单。无论是简单的数据结构还是复杂的嵌套结构，Gson都能轻松应对。通过熟练掌握Gson，你可以更好...
在Android开发中，Gson库是Google提供的一个强大的JSON数据解析工具，它使得Java对象与JSON数据之间的转换变得简单易行。本篇文章将详细介绍如何在Android应用中使用Gson库解析JSON数据，以便更好地理解这一关键知识...
在这个场景中，"使用Gson解析json并且加载json中的网络图片"涉及到的关键技术点包括Gson库的使用、JSON解析、ListView的填充以及网络图片的加载。 首先，我们要理解Gson的工作原理。Gson通过反射机制，能够自动地将...