Android中Json数据解析(二)--使用Gson、Jackson和FastJson解析Json数据

转载请注明出处：http://blog.csdn.net/yegongheng/article/details/38295227

前言

       上一篇文章我们初步学习了一下Json的特点和如何使用Json技术来解析Json数据，今天我们将来了解另外几种比较常用的Json解析技术，分别是Gson解析、Jackson解析和FastJson解析，下面我们来一一学习和分析。

Android中Gson数据解析实例

       Gson(又称 Google Gson),是Google公司2008年5月公开发布的一个开放源代码的Java库，它的主要作用是实现Json字符串和Java对象的互相转换。由于其Gson解析技术使用简单、方便的特点，目前被很多公司和个人应用。在使用Gson解析时，使用最频繁的是toJson()和fromJson()两个装换方法。其中toJson()方法主要作用是将Java对象转换成Json字符串，而fromJson()方法主要作用是将Json字符串转换成对应的Java对象或集合。下面我们通过一个实例来学习一下如何使用Gson解析来解析Json数据。为了减少代码的开发，我们在上一篇文章中的实例基础之上将原生态的Json解析方式换成Gson解析。在此之前我们先要向客户端工程下导入gson jar包，jar包可以在Google官网中下载https://code.google.com/p/google-gson/downloads/list。

       导入完jar包后，下面我们来看一下Gson解析数据的关键代码，该代码在客户端程序JsonTools.java文件中，代码如下：

[java] view plain copy

1. /**-----------------Gson数据解析----------------------------*/  
2.       
3.     /** 
4.      * 将Json字符串解析成对应的Java对象 
5.      * @param jsonStr 需要解析的Json字符串 
6.      * @param mClass 需要解析成的Java对象类型 
7.      * @return 解析后的Java对象实例 
8.      */  
9.     public static <T> T gsonToObject(String jsonStr,Class<T> mClass)  
10.     {  
11.         Gson mGson = new Gson();  
12.         T mt = mGson.fromJson(jsonStr, mClass);  
13.         return mt;  
14.     }  
15.       
16.     /** 
17.      * 将Json字符串解析成对应的ArrayList<T>集合 
18.      * @param jsonStr 需要解析的Json字符串 
19.      * @param mType 需要解析成的Java对象类型 
20.      * @return mlList 解析后的ArrayList<T>集合 
21.      */  
22.     public static <T> ArrayList<T> gsonToListObjectOrString(String jsonStr,Type mType)  
23.     {  
24.         Gson mGson = new Gson();  
25.         ArrayList<T> mlList = mGson.fromJson(jsonStr,mType);  
26.         return mlList;  
27.     }  
28.       
29.     /** 
30.      * 将Json字符串解析成对应的ArrayList<Map<String,T>>集合 
31.      * @param jsonStr 需要解析的Json字符串 
32.      * @param mType 需要解析成的Java对象类型 
33.      * @return mapsList 解析后的ArrayList<Map<String,T>>集合 
34.      */  
35.     public static <T> ArrayList<Map<String, T>> gsonGetListMapObject(String jsonStr,Type mType)  
36.     {  
37.         Gson mGson = new Gson();  
38.         ArrayList<Map<String, T>> mapsList = mGson.fromJson(jsonStr, mType);  
39.         return mapsList;  
40.     }  
41.       
42.     /** 
43.      * 获取需要转换的List<T>类型 
44.      * @param mClass  
45.      * @return mType 
46.      */  
47.     public static <T> Type getListType(Class<T> mClass){  
48.         Type mType = null;  
49.         if(mClass == Person.class){  
50.             mType = new TypeToken<List<Person>>(){}.getType();  
51.         }else if(mClass == String.class){  
52.             mType = new TypeToken<List<String>>(){}.getType();   
53.         }  
54.         return mType;  
55.     }  
56.       
57.     /** 
58.      * 获取需要转换的List<Map<String,T>>类型 
59.      * @param mClass 
60.      * @return mType 
61.      */  
62.     public static <T> Type getListMapType(Class<T> mClass){  
63.         Type mType = null;  
64.         if(mClass == Person.class){  
65.             mType = new TypeToken<List<Map<String, Person>>>(){}.getType();  
66.         }else if(mClass == String.class){  
67.             mType = new TypeToken<List<Map<String, String>>>(){}.getType();   
68.         }  
69.         return mType;  
70.     }  

然后在GsonActivity中编写展示解析完成的Json数据，具体的代码如下：

[java] view plain copy

1. public class GsonActivity extends BaseActivity {  
2.   
3.     @Override  
4.     public void onDownloaded(String result, int typeId) {  
5.         // TODO Auto-generated method stub  
6.         System.out.println("result = "+ result);  
7.         ArrayList<String> mList = new ArrayList<String>();  
8.         switch (typeId) {  
9.         case R.id.json_person:  
10.             Person mPerson = JsonTools.gsonToObject(result, Person.class);  
11.             mList.add(mPerson.toString());  
12.             break;  
13.         case R.id.json_string:  
14.             ArrayList<String> mArrayList = JsonTools.gsonToListObjectOrString(result,JsonTools.getListType(String.class));  
15.             mList.addAll(mArrayList);  
16.             break;  
17.         case R.id.json_list_person:  
18.             ArrayList<Person> mPersons = JsonTools.gsonToListObjectOrString(result,JsonTools.getListType(Person.class));  
19.             mList.addAll(personsToString(mPersons));  
20.             break;  
21.         case R.id.json_listmap_person:  
22.             ArrayList<Map<String, Person>> maps = JsonTools.gsonGetListMapObject(result,JsonTools.getListMapType(Person.class));  
23.             mList.addAll(listmappersonsToString(maps));  
24.             break;  
25.         default:  
26.             break;  
27.         }  
28.         bindData(mList);  
29.     }  
30. }  

接下来便在Android模拟器上运行程序，运行效果见文章末尾。 要学习更多有关Gson解析的知识，可参考以下网站：https://code.google.com/p/google-gson/。

Android中Jackson数据解析实例

       Jackson是一个强大的数据解析工具，它有非常强大的数据绑定功能，它提供了一个完整的框架用于将Java对象序列化成Json字符串和XML文档 序及将Json字符串和XML文档反序列化成Java对象。在此，我们主要学习如何使用Jackson完成Json数据的解析，Jackson总共提供了三种解析Json数据的方式，依次如下：

       (1)流模式(Streaming):使用JsonParser对象解析json流。它提供了json元素标记。使用JsonGenerator对象生成的json字符串、整数、布尔值等。

       (2)树形模式(Tree Traversing)：可以将Json字符串读入到JsonNode对象中，JsonNode创建了一个类似XML树形结构的数据，使用节点可以遍历到所需属性的值。

       (3)数据绑定模式(Data Binding):Jackson为该方式提供了很多的支持，即使用绑定的Json反序列化成Java对象，同时使用Java对象序列化成Json。

使用Jackson进行数据解析非常简单和方便，一般的使用Jackson解析时具有以下特点：

       (1)注释和动态bean -序列化json的未知属性映射Java对象。

       (2)注释过滤器-数据绑定,POJO的属性可以被忽略或过滤掉。这些过滤器可以设置使用注解的POJO或通过使用自定义过滤器调用类。

       (3)多态行为：如果创建一个Json使用抽象类的特定实例的对象,然后Jackson提供了一种方法来创建具体的子类。

       (4)混合：注解的POJO可用于POJO属性映射到Json属性和在数据绑定标志使用构造函数。然而,如果POJO来自第三方,那就不能带注释。那么混合它便提供了一个注释第三方类的方法。

了解完Jackson及其特点后，我们依然要通过一个实例来学习如何使用Jackson来解析Json数据，同样的，也是在上一篇文章实例的基础上将数据Json解析的方式替换成Jackson解析。在此之前我们先要向客户端工程下导入Jackson jar包，jar包可以在Jackson官网中下载:http://wiki.fasterxml.com/JacksonDownload。

好的，下面贴出Jackson解析Json数据的关键代码，如下：

[java] view plain copy

1. /**-----------------Jackson数据解析----------------------------*/  
2.     private static ObjectMapper mObjectMapper;  
3.     private static JsonGenerator mJsonGenerator;  
4.     private static ByteArrayOutputStream mOutputStream;  
5.     public JsonTools()  
6.     {  
7.         mOutputStream = new ByteArrayOutputStream();  
8.         //实例化ObjectMapper对象  
9.         mObjectMapper = new ObjectMapper();  
10.         try {  
11.             //实例化JsonGenerator对象  
12.             mJsonGenerator = mObjectMapper.getFactory().createGenerator(mOutputStream, JsonEncoding.UTF8);  
13.         } catch (IOException e) {  
14.             // TODO Auto-generated catch block  
15.             e.printStackTrace();  
16.         }  
17.     }  
18.       
19.     /** 
20.      * 将Json字符串解析成对应的Java对象 
21.      * @param jsonStr 需要解析的Json字符串 
22.      * @param mClass 需要解析成的Java对象类型 
23.      * @return mt 解析后的Java对象 
24.      */  
25.     public <T> T JacksonToObject(String jsonStr,Class<T> mClass)  
26.     {  
27.         T mt = null;  
28.         try {  
29.             mt = mObjectMapper.readValue(jsonStr, mClass);  
30.         } catch (JsonParseException e) {  
31.             // TODO Auto-generated catch block  
32.             e.printStackTrace();  
33.         } catch (JsonMappingException e) {  
34.             // TODO Auto-generated catch block  
35.             e.printStackTrace();  
36.         } catch (IOException e) {  
37.             // TODO Auto-generated catch block  
38.             e.printStackTrace();  
39.         }  
40.         return mt;  
41.     }  
42.       
43.     /** 
44.      * 将Json字符串解析成对应的ArrayList<T>对象 
45.      * @param jsonStr 需要解析的Json字符串 
46.      * @param mTypeReference 需要解析成的Java对象类型引用 
47.      * @return 解析后的ArrayList<T>集合 
48.      */  
49.     public <T> ArrayList<T> JacksonToListObjectOrString(String jsonStr,com.fasterxml.jackson.core.type.TypeReference<T> mTypeReference)  
50.     {  
51.         ArrayList<T> mList = null;  
52.         try {  
53.             mList = mObjectMapper.readValue(jsonStr, mTypeReference);  
54.         } catch (JsonParseException e) {  
55.             // TODO Auto-generated catch block  
56.             e.printStackTrace();  
57.         } catch (JsonMappingException e) {  
58.             // TODO Auto-generated catch block  
59.             e.printStackTrace();  
60.         } catch (IOException e) {  
61.             // TODO Auto-generated catch block  
62.             e.printStackTrace();  
63.         }  
64.         return mList;  
65.     }  
66.       
67.     /** 
68.      * 将Json字符串解析成对应的ArrayList<Map<String,T>>对象 
69.      * @param jsonStr 需要解析的Json字符串 
70.      * @param mTypeReference 需要解析成的Java对象类型引用 
71.      * @return 解析后的ArrayList<Map<String, T>>集合 
72.      */  
73.     public <T> ArrayList<Map<String, T>> JacksonToListMapObject(String jsonStr,com.fasterxml.jackson.core.type.TypeReference<T> mTypeReference)  
74.     {  
75.         ArrayList<Map<String, T>> mapsList = null;  
76.         try {  
77.             mapsList = mObjectMapper.readValue(jsonStr, mTypeReference);  
78.         } catch (JsonParseException e) {  
79.             // TODO Auto-generated catch block  
80.             e.printStackTrace();  
81.         } catch (JsonMappingException e) {  
82.             // TODO Auto-generated catch block  
83.             e.printStackTrace();  
84.         } catch (IOException e) {  
85.             // TODO Auto-generated catch block  
86.             e.printStackTrace();  
87.         }  
88.         return mapsList;  
89.     }  
90.       
91.     /** 
92.      * 获取需要转换的List<T>类型 
93.      * @param mClass 
94.      * @return 
95.      */  
96.     public static <T> com.fasterxml.jackson.core.type.TypeReference<T> getListTypeReference(Class<T> mClass){  
97.         com.fasterxml.jackson.core.type.TypeReference mTypeReference = null;  
98.         if(mClass == Person.class){  
99.             mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Person>>() {  
100.             };  
101.         }else if(mClass == String.class){  
102.             mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<String>>() {  
103.             };  
104.         }  
105.         return mTypeReference;  
106.     }  
107.       
108.     /** 
109.      * 获取需要转换的List<Map<String,T>>类型 
110.      * @param mClass 
111.      * @return 
112.      */  
113.     public static <T> com.fasterxml.jackson.core.type.TypeReference<T> getListMapTypeReference(Class<T> mClass){  
114.         com.fasterxml.jackson.core.type.TypeReference mTypeReference = null;  
115.         if(mClass == Person.class){  
116.             mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Map<String, Person>>>() {  
117.             };  
118.         }else if(mClass == String.class){  
119.             mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Map<String, Person>>>() {  
120.             };   
121.         }  
122.         return mTypeReference;  
123.     }  

然后在JacksonActivity中编写展示解析完成的Json数据，具体的代码如下：

[java] view plain copy

1. public class JacksonActivity extends BaseActivity {  
2.   
3.     @Override  
4.     public void onDownloaded(String result, int typeId) {  
5.         // TODO Auto-generated method stub  
6.         ArrayList<String> mList = new ArrayList<String>();  
7.         JsonTools mJsonTools = new JsonTools();  
8.         switch (typeId) {  
9.         case R.id.json_person:  
10.             Person mPerson = mJsonTools.JacksonToObject(result, Person.class);  
11.             mList.add(mPerson.toString());  
12.             break;  
13.         case R.id.json_string:  
14.             ArrayList<String> mArrayList = mJsonTools.JacksonToListObjectOrString(result,JsonTools.getListTypeReference(String.class));  
15.             mList.addAll(mArrayList);  
16.             break;  
17.         case R.id.json_list_person:  
18.             ArrayList<Person> mPersons = mJsonTools.JacksonToListObjectOrString(result,JsonTools.getListTypeReference(Person.class));  
19.             mList.addAll(personsToString(mPersons));  
20.             break;  
21.         case R.id.json_listmap_person:  
22.             ArrayList<Map<String, Person>> maps = mJsonTools.JacksonToListMapObject(result,JsonTools.getListMapTypeReference(Person.class));  
23.             mList.addAll(listmappersonsToString(maps));  
24.             break;  
25.         default:  
26.             break;  
27.         }  
28.         bindData(mList);  
29.     }  
30.   
31. }  

接下来便在Android模拟器上运行程序，运行效果见文章末尾。要学习更多有关Jackson解析的知识，可参考以下网站:http://jackson.codehaus.org/。

Android中FastJson数据解析实例

       Fastjson是阿里巴巴公司提供的一个用Java语言编写的高性能功能完善的JSON库，该库涉及的最基本功能就是序列化和反序列化。Fastjson支持java bean的直接序列化,同时也支持集合、Map、日期、Enum和泛型等的序列化。你可以使用com.alibaba.fastjson.JSON这个类进行序列化和反序列化，常用的序列化操作都可以在JSON类上的静态方法直接完成。Fastjson采用独创的算法，将parse的速度提升到极致，号称超过所有Json库。而且，使用Fastjson解析时，除了需要使用Fastjson所提供的jar包外，再不需要额外的jar包，就能够直接跑在JDK上。

了解完Fastjson及其特点后，我们依然要通过一个实例来学习如何使用Fastjson来解析Json数据，同样的，也是在上一篇文章实例的基础上将数据Json解析的方式替换成Fastjson解析。 在此之前我们先要向客户端工程下导入Fastjson jar包，由于Fastjson是开源的，其jar包和源代码可以在github官网中下载:https://github.com/alibaba/fastjson/wiki。

    下面贴出Fastjson解析JSON数据的关键代码，如下：

[java] view plain copy

1. /**-----------------FastJson数据解析----------------------------*/  
2.       
3.     /** 
4.      * 将Json字符串解析成对应的Java对象 
5.      * @param jsonStr 需要解析的Json字符串 
6.      * @param mClass 需要解析成的Java对象类型 
7.      * @return 解析后的Java对象实例 
8.      */  
9.     public static <T> T fastJsonToObject(String jsonStr,Class<T> mClass)  
10.     {  
11.         T mt = JSON.parseObject(jsonStr,mClass);  
12.         return mt;  
13.     }  
14.       
15.     /** 
16.      * 将Json字符串解析成对应的ArrayList<T>集合 
17.      * @param jsonStr 需要解析的Json字符串 
18.      * @param mType 需要解析成的Java对象类型 
19.      * @return mlList 解析后的ArrayList<T>集合 
20.      */  
21.     public static <T> ArrayList<T> fastJsonToListObjectOrString(String jsonStr,Class<T> mClass)  
22.     {  
23.         ArrayList<T> mList = (ArrayList<T>) JSON.parseArray(jsonStr, mClass);  
24.         return mList;  
25.     }  
26.       
27.     /** 
28.      * 将Json字符串解析成对应的ArrayList<Map<String,T>>集合 
29.      * @param jsonStr 需要解析的Json字符串 
30.      * @param mType 需要解析成的Java对象类型 
31.      * @return mapsList 解析后的ArrayList<Map<String,T>>集合 
32.      */  
33.     public static <T> ArrayList<Map<String, T>> fastJsonGetListMapObject(String jsonStr,TypeReference<T> mTypeReference)  
34.     {  
35.         ArrayList<Map<String, T>> mapsList = (ArrayList<Map<String, T>>) JSON.parseObject(jsonStr, mTypeReference);  
36.         return mapsList;  
37.     }  
38.       
39.     /** 
40.      * 获取需要转换的List<Map<String,T>>类型 
41.      * @param mClass 
42.      * @return mType 
43.      */  
44.     public static <T> TypeReference fastJsonGetetListMapTypeReference(Class<T> mClass){  
45.         TypeReference mTypeReference = null;  
46.         if(mClass == Person.class){  
47.             mTypeReference = new TypeReference<ArrayList<Map<String, Person>>>(){};  
48.         }else if(mClass == String.class){  
49.             mTypeReference = new TypeReference<ArrayList<Map<String, String>>>(){};  
50.         }  
51.         return mTypeReference;  
52.     }  

然后在FastJsonActivity中编写展示解析完成的Json数据，具体的代码如下：

[java] view plain copy

1. public class FastJsonActivity extends BaseActivity {  
2.   
3.     @Override  
4.     public void onDownloaded(String result, int typeId) {  
5.         // TODO Auto-generated method stub  
6.         ArrayList<String> mList = new ArrayList<String>();  
7.         switch (typeId) {  
8.         case R.id.json_person:  
9.             Person mPerson = JsonTools.fastJsonToObject(result, Person.class);  
10.             mList.add(mPerson.toString());  
11.             break;  
12.         case R.id.json_string:  
13.             ArrayList<String> mArrayList = JsonTools.fastJsonToListObjectOrString(result, String.class);  
14.             mList.addAll(mArrayList);  
15.             break;  
16.         case R.id.json_list_person:  
17.             ArrayList<Person> mPersons = JsonTools.fastJsonToListObjectOrString(result, Person.class);  
18.             mList.addAll(personsToString(mPersons));  
19.             break;  
20.         case R.id.json_listmap_person:  
21.             ArrayList<Map<String, Person>> maps = JsonTools.fastJsonGetListMapObject(result, JsonTools.fastJsonGetetListMapTypeReference(Person.class));  
22.             mList.addAll(listmappersonsToString(maps));  
23.             break;  
24.         default:  
25.             break;  
26.         }  
27.         bindData(mList);  
28.     }  
29.   
30. }  

接下来便在Android模拟器上运行程序，我们来操作Gson、Jackson和Fastjson三种解析方式的运行效果，效果图如下：

要学习更多有关FastJson解析的知识，可参考以下网站:https://github.com/alibaba/fastjson/wiki/%E9%A6%96%E9%A1%B5

扩展：通过上面对三种json解析技术的学习我们可以发现，它们比Android内置的原生态json技术使用起来更加简单和方便，而且据众多网友测试后得出结论Json、Gson、FastJson和Jackson四种Json解析技术的的解析速度排名依次为： Fastjson >  Jackson > Gson > Json。下面是阿里巴巴公司提供的一份反应各种json解析技术的解析速度的图表，如下图示：

该结论争议比较大，众多网友都有不同看法。咱对该结论的对错与否暂先不讨论，总之，笔者认为只要开发者们觉得使用方便，都可以随自己的意愿选择其中一种解析技术(笔者喜欢使用Fastjson和Gson)，当然，这得是在不影响应用的用户体验的前提之下。个人认为上图的数据具有一定的参考作用，读者在选择使用哪一种json解析库时，可以依此作为参考依据。

总结：Json解析作为常用的数据解析技术，开发者应当熟练掌握和运用。工欲善其事，必先利其器，使用第三方Json解析库可以使我们的开发工作变得更加快速和高效。今天我们学习了Gson、Jackson和Fastjson三种Json解析技术，了解了其各自的特点及其如何具体使用。当然，支持Json解析的第三方Json解析库还有很多，较为常用的有jsonp、json-lib和Json-smart等，感兴趣的读者可以自行研究学习。

源代码下载，请戳下面：

• GITHUB下载
• CSDN下载