Gson与FastJson比较

一. 简介和优劣

1.Google的Gson

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。

而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。

类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。

Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

2.阿里巴巴的FastJson

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。

无依赖，不需要例外额外的jar，能够直接跑在JDK上。 FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。

FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

3. 其他

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。json-lib在功能和性能上面都不能满足现在互联网化的需求。

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。

而且Jackson社区相对比较活跃，更新速度也比较快。

Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。

Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

综上,在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，

如果只是功能要求，没有性能要求，可以使用google的Gson，

如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean。

二、基本使用方式

Gson

//解成对象
Fromat mFromat = new Gson().fromJson(jsonStringObject, Fromat.class);

//解成对象组
LinkedList<Fromat> list = new LinkedList<MainActivity.Fromat>();
Type type = new TypeToken<LinkedList<Fromat>>(){}.getType();
list = new Gson().fromJson(jsonStringArray, type);

//泛型统一封装时 需要传个 type 进来
new TypeToken<LinkedList<Fromat>>(){}.getType();
fromJson(String json, Type typeOfT)
public <T> T fromJson(String json, Type typeOfT)

fastJson

//解析成对象
Fromat fastjsonObject = JSON.parseObject(jsonObjectString, Fromat.class);

//解析成对象组
List<Fromat> fastjsonArray = JSON.parseArray(jsonArrayString, Fromat.class);

//泛型统一封装时 需要传个 type 进来 或者TypeReference 也可以也是调用的type
new TypeReference<Fromat>() {}
new TypeReference<Fromat>() {}.getType()
public static <T> T parseObject(String input, Type clazz, Feature... features)
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features)

三、细节比较

1、属性和set方法名称不一致时

现在我有这么一个Bean,属性名为firstName，但是它的set方法却是setName()，而不是setFirstName()

下面我使用Gson与FastJson分别将这样的一个Bean转成一个Json字符串，大家猜会有什么区别？

    @Test
    public void toJson() {
        Bean bean = new Bean();
        bean.setAge(24);
        bean.setName("扎巴也"); //方法是setName,属性是firstName

        String fastJson = JSON.toJSONString(bean);
        System.out.println("fastJson=" + fastJson);

        String gson = new Gson().toJson(bean);
        System.out.println("gson=" + gson);
    }

输出结果：

fastJson={"age":24,"name":"扎巴也"}
gson={"firstName":"扎巴也","age":24}

序列化时fastJson是按照set方法的名字来转换的，而gson则是按照属性的名字来转换的。

不信？好，我们再来看看反序列化时会怎样？

@Test
    public void fromJson() {
        String json = "{\"age\":24,\"name\":\"扎巴也\"}";

        Bean fastjson = JSON.parseObject(json, Bean.class);
        System.out.println("fastJson=" + fastjson.toString());

        Bean gson = new Gson().fromJson(json, Bean.class);
        System.out.println("gson=" + gson.toString());
    }

输出结果：

fastJson=Bean{firstName=‘扎巴也‘, age=24}
gson=Bean{firstName=‘null‘, age=24}

因为Bean类里面有name的set方法，所以fastJson解析时调用了setName,所以firstName有值

但是Bean类里面却没有name属性，所以gson解析时，firstName没有值

2、有属性，无set方法

现在我有这么一个Person,属性名为name，但是它没有name的set方法

那么，我来解析这样一个字符串时，FastJson和Gson会有什么区别呢？

{"age":24,"name":"扎巴也"}

测试代码：

@Test
    public void fromJsonNoSet() {
        String json = "{\"age\":24,\"name\":\"扎巴也\"}";

        Person fastjson = JSON.parseObject(json, Person.class);
        System.out.println("fastJson=" + fastjson.toString());

        Person gson = new Gson().fromJson(json, Person.class);
        System.out.println("gson=" + gson.toString());
    }

输出结果:

fastJson=Person{name=‘null‘, age=24}
gson=Person{name=‘扎巴也‘, age=24}

因为Person没有name的set方法，所以fastJson解析的name为null

再次证明，fastJson是按照set方法的名字来转换的，而gson则是按照属性的名字来转换的。

那么，无属性，有set方法时，两者有什么区别呢？(其实没有属性的话，set方法调用了没啥作用）

测试代码：

@Test
    public void fromJsonNoFiled() {
        String json = "{\"age\":24,\"name\":\"扎巴也\"}";

        Student fastjson = JSON.parseObject(json, Student.class);
        System.out.println("fastJson=" + fastjson.toString());

        Student gson = new Gson().fromJson(json, Student.class);
        System.out.println("gson=" + gson.toString());
    }

输出结果：

调用了setName：扎巴也
fastJson=Student{age=24}
gson=Student{age=24}

fastJson调用了set方法，而gson没有调用set方法。

同样证明，fastJson是按照set方法的名字来转换的，而gson则是按照属性的名字来转换的。

3、无默认的无参构造方法

现在有这么一个Teacher类，他只有一个两个参数的构造方法，没有默认的无参构造方法，那么，我来解析这样一个字符串时，FastJson和Gson会有什么区别呢？

{"age":24,"name":"扎巴也"}

测试代码：

    @Test
    public void fromJsonNoDefaultConstructor() {
        String json = "{\"age\":24,\"name\":\"扎巴也\"}";

        Teacher gson = new Gson().fromJson(json, Teacher.class);
        System.out.println("gson=" + gson.toString());

        Teacher fastjson = JSON.parseObject(json, Teacher.class);
        System.out.println("fastJson=" + fastjson.toString());
    }

这里，Gson可以正常的解析，但是，fastJson则会报错，因为没有默认的无参构造方法。

这说明了反序列化时，fastJson是通过无参构造方法来创建对象的，那么gson又是怎么创建对象的呢？(是调用了Unsafe.allocateInstance()这个native方法来创建对象的。

但是，我们知道，这个方法直接操作内存，是不安全的，那么，如果反序列化的那个类，存在默认的无参构造方法呢？)

4、有默认的无参构造方法

    @Test
    public void fromJsonHasDefaultConstructor() {
        String json = "{\"age\":24,\"name\":\"扎巴也\"}";

        Boss gson = new Gson().fromJson(json, Boss.class);
        System.out.println("gson=" + gson.toString());

        Boss fastjson = JSON.parseObject(json, Boss.class);
        System.out.println("fastJson=" + fastjson.toString());
    }

gson和fastJson都调用了默认的无参构造方法.

至此，我们可以得出结论：

有默认的无参构造方法时，gson和fastJson都会调用它来创建对象，没有默认的无参构造方法时，fastJson会直接报错！而gson则会调用Unsafe.allocateInstance()这个native方法直接在内存上创建对象。

四、Gson中使用泛型

例：JSON字符串数组

当我们要通过Gson解析这个json时，一般有两种方式：使用数组，使用List。而List对于增删都是比较方便的，所以实际使用是还是List比较多。

数组比较简单

Gson gson = new Gson();
String jsonArray = "[\"Android\",\"Java\",\"PHP\"]";
String[] strings = gson.fromJson(jsonArray, String[].class);

但对于List将上面的代码中的 String[].class 直接改为 List

为了解决的上面的问题，Gson为我们提供了TypeToken来实现对泛型的支持，所以当我们希望使用将以上的数据解析为List

Gson gson = new Gson();
String jsonArray = "[\"Android\",\"Java\",\"PHP\"]";
String[] strings = gson.fromJson(jsonArray, String[].class);
List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {}.getType());

注：TypeToken的构造方法是protected修饰的,所以上面才会写成new TypeToken

参考：

https://www.jianshu.com/p/e740196225a4

https://blog.csdn.net/lckj686/article/details/51587073

https://blog.csdn.net/xiaoke815/article/details/52920405

https://www.jianshu.com/p/153111dde324

原文地址：https://www.cnblogs.com/john8169/p/9211401.html

时间： 2024-10-29 00:11:00

Gson与FastJson比较的相关文章

Gson 与 fastJson 在使用上的差异（fastJson的优点）

一.android 常用的json解析方式 Android 开发上常用的json解析方式有:Gson, fastJson,jackson. 因为jackjson jar包会比较大点(700+k),Gson和fastjson的功能又基本够用,所以一直没正式用过jackjson.自己有用的就是Gson和fastjson 二.基本使用方式 Gson //解成对象 Fromat mFromat = new Gson().fromJson(jsonStringObject, Fromat.class);

各个JSON技术的比较（Jackson，Gson，Fastjson）的对比

JSON技术的调研报告 一 .各个JSON技术的简介和优劣 1.json-lib json-lib最开始的也是应用最广泛的json解析工具,json-lib 不好的地方确实是依赖于很多第三方包, 包括commons-beanutils.jar,commons-collections-3.2.jar,commons-lang-2.6.jar,commons-logging-1.1.1.jar,ezmorph-1.0.6.jar, 对于复杂类型的转换,json-lib对于json转换成bean还有缺

Android JSON解析库Gson和Fast-json的使用对比和图书列表小案例

Android JSON解析库Gson和Fast-json的使用对比和图书列表小案例 继上篇json解析,我用了原生的json解析,但是在有些情况下我们不得不承认,一些优秀的json解析框架确实十分的好用,今天我们为了博客的保质保量,也就不分开写,我们直接拿比较火的Gson和Fast-json来使用,末尾在进行一些分析 Android JSON原生解析的几种思路,以号码归属地,笑话大全,天气预报为例演示 一.各有千秋 两大解析库的东家都是巨头,一个来自于Google官方,一个来自阿里巴巴,我们这

Android JSON 解析库的使用 - Gson 和 fast-json

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式.它基于ECMAScript的一个子集. JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C.C++.C#.Java.JavaScript.Perl.Python等).这些特性使JSON成为理想的数据交换语言. 易于人阅读和编写,同时也易于机器解析和生成(网络传输速率). GSON是由谷歌官方推出的 JSON 与 Java 对象转化的 Java类库 fast-json 阿里推

Gson和Fastjson

1.PersonBean package com.louis.fastjsondemo; /** * Created by Administrator on 2016/2/26. */ public class PersonBean { private int id; private String name; private String address; public int getId() { return id; } public void setId(int id) { this.id

Android JSON、GSON、FastJson的封装与解析

声明: 1.本帖只提供代码,不深入讲解原理.如果读者想要深入了解,那就不要在这个帖子上浪费时间了 2.客户端用的是Google官方的Volley访问服务器,具体了解Volley请戳 这里 3.本帖三种数据解析的DEMO都用到了下面这个Person类,贴出来: 1 public class Person { 2 private String name; 3 private int age; 4 private String address; 5 6 public Person() { 7 8 }

Json解析速度比较-Android API、Gson、Fastjson

IOS现成的API里的json解析速度非常快,这里就不说了,今天对比一下Android里面json的解析库. 首先第一个是Android API里面自带的json解析,其次是谷歌提供的Gson解析库(开源),其次是在网上看到的解析很快速的阿里巴巴分享的Fastjson包.Android自带的json解析大家一定都很熟悉了,这里不介绍了,这里详细说说谷歌提供的另一套解析库Gson: gson的使用方法非常的简单.只需要将需要解析的json字符串和对应的Bean类xing型传递给GSON类的from

Volley 结合GSON或FastJson用法

自定义GSON类 1 public class GsonRequest<T> extends Request<T> { 2 private final Gson mGson = new Gson(); 3 private final Class<T> mClazz; 4 private final Listener<T> mListener; 5 private final Map<String, String> mHeaders; 6 7 pu

Gson和Fastjson的使用

转载自:JSON技术的调研报告 一.Google的Gson包的使用简单介绍. Gson类:解析json的最基础的工具类 JsonParser类:解析器来解析JSON到JsonElements的解析树 JsonElement类:一个类代表的JSON元素 JsonObject类:JSON对象类型 JsonArray类:JsonObject数组 TypeToken类:用于创建type,比方泛型List (1)maven依赖 com.google.code.gson gson 2.3.1 开源地址 ht