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

转载请注明出处：/article/7809133.html

前言

上一篇文章我们初步学习了一下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文件中，代码如下：

/**-----------------Gson数据解析----------------------------*/

/**
* 将Json字符串解析成对应的Java对象
* @param jsonStr 需要解析的Json字符串
* @param mClass 需要解析成的Java对象类型
* @return 解析后的Java对象实例
*/
public static <T> T gsonToObject(String jsonStr,Class<T> mClass)
{
Gson mGson = new Gson();
T mt = mGson.fromJson(jsonStr, mClass);
return mt;
}

/**
* 将Json字符串解析成对应的ArrayList<T>集合
* @param jsonStr 需要解析的Json字符串
* @param mType 需要解析成的Java对象类型
* @return mlList 解析后的ArrayList<T>集合
*/
public static <T> ArrayList<T> gsonToListObjectOrString(String jsonStr,Type mType)
{
Gson mGson = new Gson();
ArrayList<T> mlList = mGson.fromJson(jsonStr,mType);
return mlList;
}

/**
* 将Json字符串解析成对应的ArrayList<Map<String,T>>集合
* @param jsonStr 需要解析的Json字符串
* @param mType 需要解析成的Java对象类型
* @return mapsList 解析后的ArrayList<Map<String,T>>集合
*/
public static <T> ArrayList<Map<String, T>> gsonGetListMapObject(String jsonStr,Type mType)
{
Gson mGson = new Gson();
ArrayList<Map<String, T>> mapsList = mGson.fromJson(jsonStr, mType);
return mapsList;
}

/**
* 获取需要转换的List<T>类型
* @param mClass
* @return mType
*/
public static <T> Type getListType(Class<T> mClass){
Type mType = null;
if(mClass == Person.class){
mType = new TypeToken<List<Person>>(){}.getType();
}else if(mClass == String.class){
mType = new TypeToken<List<String>>(){}.getType();
}
return mType;
}

/**
* 获取需要转换的List<Map<String,T>>类型
* @param mClass
* @return mType
*/
public static <T> Type getListMapType(Class<T> mClass){
Type mType = null;
if(mClass == Person.class){
mType = new TypeToken<List<Map<String, Person>>>(){}.getType();
}else if(mClass == String.class){
mType = new TypeToken<List<Map<String, String>>>(){}.getType();
}
return mType;
}

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

public class GsonActivity extends BaseActivity {

@Override
public void onDownloaded(String result, int typeId) {
// TODO Auto-generated method stub
System.out.println("result = "+ result);
ArrayList<String> mList = new ArrayList<String>();
switch (typeId) {
case R.id.json_person:
Person mPerson = JsonTools.gsonToObject(result, Person.class);
mList.add(mPerson.toString());
break;
case R.id.json_string:
ArrayList<String> mArrayList = JsonTools.gsonToListObjectOrString(result,JsonTools.getListType(String.class));
mList.addAll(mArrayList);
break;
case R.id.json_list_person:
ArrayList<Person> mPersons = JsonTools.gsonToListObjectOrString(result,JsonTools.getListType(Person.class));
mList.addAll(personsToString(mPersons));
break;
case R.id.json_listmap_person:
ArrayList<Map<String, Person>> maps = JsonTools.gsonGetListMapObject(result,JsonTools.getListMapType(Person.class));
mList.addAll(listmappersonsToString(maps));
break;
default:
break;
}
bindData(mList);
}
}

接下来便在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数据的关键代码，如下：

/**-----------------Jackson数据解析----------------------------*/
private static ObjectMapper mObjectMapper;
private static JsonGenerator mJsonGenerator;
private static ByteArrayOutputStream mOutputStream;
public JsonTools()
{
mOutputStream = new ByteArrayOutputStream();
//实例化ObjectMapper对象
mObjectMapper = new ObjectMapper();
try {
//实例化JsonGenerator对象
mJsonGenerator = mObjectMapper.getFactory().createGenerator(mOutputStream, JsonEncoding.UTF8);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

/**
* 将Json字符串解析成对应的Java对象
* @param jsonStr 需要解析的Json字符串
* @param mClass 需要解析成的Java对象类型
* @return mt 解析后的Java对象
*/
public <T> T JacksonToObject(String jsonStr,Class<T> mClass)
{
T mt = null;
try {
mt = mObjectMapper.readValue(jsonStr, mClass);
} catch (JsonParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JsonMappingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return mt;
}

/**
* 将Json字符串解析成对应的ArrayList<T>对象
* @param jsonStr 需要解析的Json字符串
* @param mTypeReference 需要解析成的Java对象类型引用
* @return 解析后的ArrayList<T>集合
*/
public <T> ArrayList<T> JacksonToListObjectOrString(String jsonStr,com.fasterxml.jackson.core.type.TypeReference<T> mTypeReference)
{
ArrayList<T> mList = null;
try {
mList = mObjectMapper.readValue(jsonStr, mTypeReference);
} catch (JsonParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JsonMappingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return mList;
}

/**
* 将Json字符串解析成对应的ArrayList<Map<String,T>>对象
* @param jsonStr 需要解析的Json字符串
* @param mTypeReference 需要解析成的Java对象类型引用
* @return 解析后的ArrayList<Map<String, T>>集合
*/
public <T> ArrayList<Map<String, T>> JacksonToListMapObject(String jsonStr,com.fasterxml.jackson.core.type.TypeReference<T> mTypeReference)
{
ArrayList<Map<String, T>> mapsList = null;
try {
mapsList = mObjectMapper.readValue(jsonStr, mTypeReference);
} catch (JsonParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JsonMappingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return mapsList;
}

/**
* 获取需要转换的List<T>类型
* @param mClass
* @return
*/
public static <T> com.fasterxml.jackson.core.type.TypeReference<T> getListTypeReference(Class<T> mClass){
com.fasterxml.jackson.core.type.TypeReference mTypeReference = null;
if(mClass == Person.class){
mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Person>>() {
};
}else if(mClass == String.class){
mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<String>>() {
};
}
return mTypeReference;
}

/**
* 获取需要转换的List<Map<String,T>>类型
* @param mClass
* @return
*/
public static <T> com.fasterxml.jackson.core.type.TypeReference<T> getListMapTypeReference(Class<T> mClass){
com.fasterxml.jackson.core.type.TypeReference mTypeReference = null;
if(mClass == Person.class){
mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Map<String, Person>>>() {
};
}else if(mClass == String.class){
mTypeReference = new com.fasterxml.jackson.core.type.TypeReference<List<Map<String, Person>>>() {
};
}
return mTypeReference;
}

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

public class JacksonActivity extends BaseActivity {

@Override
public void onDownloaded(String result, int typeId) {
// TODO Auto-generated method stub
ArrayList<String> mList = new ArrayList<String>();
JsonTools mJsonTools = new JsonTools();
switch (typeId) {
case R.id.json_person:
Person mPerson = mJsonTools.JacksonToObject(result, Person.class);
mList.add(mPerson.toString());
break;
case R.id.json_string:
ArrayList<String> mArrayList = mJsonTools.JacksonToListObjectOrString(result,JsonTools.getListTypeReference(String.class));
mList.addAll(mArrayList);
break;
case R.id.json_list_person:
ArrayList<Person> mPersons = mJsonTools.JacksonToListObjectOrString(result,JsonTools.getListTypeReference(Person.class));
mList.addAll(personsToString(mPersons));
break;
case R.id.json_listmap_person:
ArrayList<Map<String, Person>> maps = mJsonTools.JacksonToListMapObject(result,JsonTools.getListMapTypeReference(Person.class));
mList.addAll(listmappersonsToString(maps));
break;
default:
break;
}
bindData(mList);
}

}

接下来便在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数据的关键代码，如下：

/**-----------------FastJson数据解析----------------------------*/

/**
* 将Json字符串解析成对应的Java对象
* @param jsonStr 需要解析的Json字符串
* @param mClass 需要解析成的Java对象类型
* @return 解析后的Java对象实例
*/
public static <T> T fastJsonToObject(String jsonStr,Class<T> mClass)
{
T mt = JSON.parseObject(jsonStr,mClass);
return mt;
}

/**
* 将Json字符串解析成对应的ArrayList<T>集合
* @param jsonStr 需要解析的Json字符串
* @param mType 需要解析成的Java对象类型
* @return mlList 解析后的ArrayList<T>集合
*/
public static <T> ArrayList<T> fastJsonToListObjectOrString(String jsonStr,Class<T> mClass)
{
ArrayList<T> mList = (ArrayList<T>) JSON.parseArray(jsonStr, mClass);
return mList;
}

/**
* 将Json字符串解析成对应的ArrayList<Map<String,T>>集合
* @param jsonStr 需要解析的Json字符串
* @param mType 需要解析成的Java对象类型
* @return mapsList 解析后的ArrayList<Map<String,T>>集合
*/
public static <T> ArrayList<Map<String, T>> fastJsonGetListMapObject(String jsonStr,TypeReference<T> mTypeReference)
{
ArrayList<Map<String, T>> mapsList = (ArrayList<Map<String, T>>) JSON.parseObject(jsonStr, mTypeReference);
return mapsList;
}

/**
* 获取需要转换的List<Map<String,T>>类型
* @param mClass
* @return mType
*/
public static <T> TypeReference fastJsonGetetListMapTypeReference(Class<T> mClass){
TypeReference mTypeReference = null;
if(mClass == Person.class){
mTypeReference = new TypeReference<ArrayList<Map<String, Person>>>(){};
}else if(mClass == String.class){
mTypeReference = new TypeReference<ArrayList<Map<String, String>>>(){};
}
return mTypeReference;
}

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

public class FastJsonActivity extends BaseActivity {

@Override
public void onDownloaded(String result, int typeId) {
// TODO Auto-generated method stub
ArrayList<String> mList = new ArrayList<String>();
switch (typeId) {
case R.id.json_person:
Person mPerson = JsonTools.fastJsonToObject(result, Person.class);
mList.add(mPerson.toString());
break;
case R.id.json_string:
ArrayList<String> mArrayList = JsonTools.fastJsonToListObjectOrString(result, String.class);
mList.addAll(mArrayList);
break;
case R.id.json_list_person:
ArrayList<Person> mPersons = JsonTools.fastJsonToListObjectOrString(result, Person.class);
mList.addAll(personsToString(mPersons));
break;
case R.id.json_listmap_person:
ArrayList<Map<String, Person>> maps = JsonTools.fastJsonGetListMapObject(result, JsonTools.fastJsonGetetListMapTypeReference(Person.class));
mList.addAll(listmappersonsToString(maps));
break;
default:
break;
}
bindData(mList);
}

}

接下来便在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下载