Gson、Fastjson和Jackson速度对比

Gson

1. 依赖

 <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
       <version>2.8.5</version>
 </dependency>

2. 工具类

private GsonUtil() {
    }

    private static Gson gson = null;

    static {
        gson = new Gson();
    }

    /**
     * 将object对象转成json字符串
     *
     * @param object
     * @return
     */
    public static String getGsonByObject(Object object) {
        String gsonString = null;
        if (gson != null) {
            gsonString = gson.toJson(object);
        }
        return gsonString;
    }


    /**
     * 将gsonString转成泛型bean
     *
     * @param gsonString
     * @param cls
     * @return
     */
    public static <T> T gsonToBean(String gsonString, Class<T> cls) {
        T t = null;
        if (gson != null) {
            t = gson.fromJson(gsonString, cls);
        }
        return t;
    }


    /**
     * 转成list
     * 泛型在编译期类型被擦除导致报错
     * @param gsonString
     * @param cls
     * @return
     */
    public static <T> List<T> gsonToList(String gsonString, Class<T> cls) {
        List<T> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString, new TypeToken<List<T>>() {
            }.getType());
        }
        return list;
    }


    /**
     * 转成list
     * 解决泛型问题
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> List<T> jsonToList(String json, Class<T> cls) {
        Gson gson = new Gson();
        List<T> list = new ArrayList<T>();
        JsonArray array = new JsonParser().parse(json).getAsJsonArray();
        for(final JsonElement elem : array){
            list.add(gson.fromJson(elem, cls));
        }
        return list;
    }




    /**
     * 转成list中有map的
     *
     * @param gsonString
     * @return
     */
    public static <T> List<Map<String, T>> gsonToListMaps(String gsonString) {
        List<Map<String, T>> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString,
                    new TypeToken<List<Map<String, T>>>() {
                    }.getType());
        }
        return list;
    }


    /**
     * 转成map的
     *
     * @param gsonString
     * @return
     */
    public static <T> Map<String, T> gsonToMaps(String gsonString) {
        Map<String, T> map = null;
        if (gson != null) {
            map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
            }.getType());
        }
        return map;
    }

3. 实体

@Data
public class UserDto {
    private Integer id;
    private String account;
    private String userName;
    private String idCard;
    private String Addr;
}

4. 测试说明，程序封装200000个UserDto对象，测试10次。
5. 序列化测试（Object转Json）

工具	次数	毫秒
gson	第1次	585
gson	第2次	463
gson	第3次	536
gson	第4次	626
gson	第5次	555
gson	第6次	521
gson	第7次	527
gson	第8次	448
gson	第9次	568
gson	第10次	696

6. 反序列化（Json转Object）

工具	次数	毫秒
gson	第1次	357
gson	第2次	314
gson	第3次	319
gson	第4次	296
gson	第5次	289
gson	第6次	324
gson	第7次	301
gson	第8次	299
gson	第9次	313
gson	第10次	326

---

Fastjson

1. 依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.29</version>
        </dependency>

2. 工具类

  private FastJsonUtil() {
    }
    
    private static SerializerFeature[] feature = {
            //解决FastJson循环引用的问题
            SerializerFeature.DisableCircularReferenceDetect,
            //排序
            SerializerFeature.SortField
    };
    private static SerializeConfig mapping = new SerializeConfig();

    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
        mapping.put(Timestamp.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));//数据库的一个时间类型
    }

    /**
     * 将对象转换成JSON字符串 --固定时间格式"yyyy-MM-dd HH:mm:ss"
     *
     * @param BO/VO,map,数组,list 对象
     * @return JSON字符串
     * @说明：对bean中有Date类型的数据可以成功转换成yyyy-MM-dd HH:mm:ss格式的时间类型,例如："barDate":yyyy-MM-dd HH:mm:ss
     */
    public static String getJsonByObj(Object bean) {
        return getJsonByObj(bean, mapping);
    }

    /**
     * 将对象转换成JSON字符串 --特定时间格式--所有Key为小写
     *
     * @param BO/VO,map,数组,list 对象
     * @return JSON字符串
     * @dateType 时间格式转换后的字符串格式，例如yyyy-MM-dd HH:mm:ss
     * @说明：对bean中有Date类型的数据可以成功转换成yyyy-MM-dd HH:mm:ss格式的时间类型,例如："barDate":yyyy-MM-dd HH:mm:ss
     */
    public static String getJsonByObj(Object bean, String dateType) {
        SerializeConfig zdymapping = new SerializeConfig();
        zdymapping.put(Date.class, new SimpleDateFormatSerializer(dateType));
        return getJsonByObj(bean, zdymapping);
    }

    /**
     * 将对象转换成JSON字符串 ---效率高一些--不处理key 也不处理循环引用的问题--也不处理时间格式
     *
     * @param BO/VO,map,数组,list 对象
     * @return JSON字符串
     * @说明：对bean中有Date类型的数据可以成功转换成long格式的时间类型,例如："barDate":1458268099098
     */
    public static String getJsonDefaultByObj(Object bean) {
        return JSON.toJSONString(bean);
    }

    /**
     * 将JSON数据转换为ListBean集合
     *
     * @param <T>
     * @param json  JSON数组数据
     * @param calzz 待转换的Bean类型 --LinkedCaseInsensitiveMap
     * @return
     */
    public static <T> List<T> getListBean(String json, Class<T> calzz) {
        return JSON.parseArray(json, calzz);
    }

    /**
     * 将JSON数据转换为List集合
     *
     * @param <T>
     * @param json  JSON数组数据
     * @param calzz 待转换的Bean类型 --LinkedCaseInsensitiveMap
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static List getList(String json, Class calzz) {
        return getListBean(json, calzz);
    }

    /**
     * 将JSON数据转换为 Java Bea n对象
     *
     * @param json  JSON字符串
     * @param calzz 待转换的Bean类型--LinkedCaseInsensitiveMap
     * @return
     */
    public static <T> T getObjet(String json, Class<T> calzz) {
        return JSON.parseObject(json, calzz);
    }

    /***
     * 通用封装--获取json字符串
     * @param bean 对象
     * @param mappingx 时间类型计划等
     * @return
     */
    private static String getJsonByObj(Object bean, SerializeConfig mappingx) {
        String json = JSON.toJSONString(bean, mappingx,  feature);
        json = stringToJson(json);
        return json; //所有Key为小写
    }

    /**
     * 当文本中含有如下特殊字符时，此方法可以成功处理，让其在前台被正确解析，注意：此法不能处理单引号
     *
     * @param s
     * @return
     */
    public static String stringToJson(String s) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            switch (c) {
				/*case '\"':
					sb.append("\\\"");
					break;*/
                case '\\':   //如果不处理单引号，可以释放此段代码，若结合下面的方法处理单引号就必须注释掉该段代码
                    sb.append("\\\\");
                    break;
                case '/':
                    sb.append("\\/");
                    break;
                case '\b':      //退格
                    sb.append("\\b");
                    break;
                case '\f':      //走纸换页
                    sb.append("\\f");
                    break;
                case '\n':
                    sb.append("\\n"); //换行
                    break;
                case '\r':      //回车
                    sb.append("\\r");
                    break;
                case '\t':      //横向跳格
                    sb.append("\\t");
                    break;
                default:
                    sb.append(c);
            }
        }
        return sb.toString();
    }

3. 实体

@Data
public class UserDto {
    private Integer id;
    private String account;
    private String userName;
    private String idCard;
    private String Addr;
}

4. 测试说明，程序封装200000个UserDto对象，测试10次。
5. 序列化测试（Object转Json）

工具	次数	毫秒
fastjson	第1次	651
fastjson	第2次	673
fastjson	第3次	632
fastjson	第4次	660
fastjson	第5次	669
fastjson	第6次	697
fastjson	第7次	719
fastjson	第8次	817
fastjson	第9次	669
fastjson	第10次	709

6. 反序列化测试（Json转Object）

工具	次数	毫秒
fastjson	第1次	143
fastjson	第2次	140
fastjson	第3次	140
fastjson	第4次	158
fastjson	第5次	161
fastjson	第6次	159
fastjson	第7次	155
fastjson	第8次	158
fastjson	第9次	179
fastjson	第10次	157

---

Jackson

1. 依赖

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.6</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.6</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.6</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>

2. 工具类

private JacksonUtil() {
    }

    private static final ObjectMapper mObjectMapper = new ObjectMapper();
    private static final ObjectMapper mObjectMapperLowerCaseWithUnderScores = new ObjectMapper();

    //在这里进行配置全局
    static {
        //有时JSON字符串中含有我们并不需要的字段，那么当对应的实体类中不含有该字段时，会抛出一个异常，告诉你有些字段（java 原始类型）没有在实体类中找到
        //设置为false即不抛出异常，并设置默认值 int->0 double->0.0
        mObjectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        mObjectMapperLowerCaseWithUnderScores.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        //序列化时添加下划线
        mObjectMapperLowerCaseWithUnderScores.setPropertyNamingStrategy(new PropertyNamingStrategy.SnakeCaseStrategy());
    }

    public static String beanToJson(Object object) {
        if (object != null) {
            try {
                return mObjectMapper.writeValueAsString(object);
            } catch (JsonProcessingException e) {
                System.out.println("bean to json exception");
            }
        }
        return "";
    }

    public static <T> T jsonToBean(String json, Class<T> classType) {
        if (StringUtils.isNotBlank(json) && classType != null) {
            try {
                return mObjectMapper.readValue(json, classType);
            } catch (IOException e) {
                System.out.println("json to bean exception");
            }
        }
        return null;
    }

    public static <T> List<T> jsonToList(String json, Class<T> classType) {
        if (StringUtils.isNotBlank(json) && classType != null) {
            try {
                return mObjectMapper.readValue(json, mObjectMapper.getTypeFactory().constructCollectionType(List.class, classType));
            } catch (IOException e) {
                System.out.println("json to list exception");
            }
        }
        return null;
    }

    public static <k, v> Map<k, v> jsonToMap(String json, Class<k> kType, Class<v> vType) {
        if (StringUtils.isNotBlank(json)) {
            try {
                return mObjectMapper.readValue(json, mObjectMapper.getTypeFactory().constructMapType(Map.class, kType, vType));
            } catch (IOException e) {
                System.out.println("json to Map exception");
            }
        }
        return null;
    }

    public static String beanToJsonByLowerCase(Object object) {
        if (object != null) {
            try {
                return mObjectMapperLowerCaseWithUnderScores.writeValueAsString(object);
            } catch (JsonProcessingException e) {
                System.out.println("bean to json with lowerCase exception");
            }
        }
        return "";
    }

    public static <T> T jsonToBeanByLowerCase(String json, Class<T> classType) {
        if (StringUtils.isNotBlank(json)) {
            try {
                return mObjectMapperLowerCaseWithUnderScores.readValue(json, classType);
            } catch (IOException e) {
                System.out.println("json to Bean with lowerCase exception");
            }
        }
        return null;
    }

3. 实体

@Data
public class UserDto {
    private Integer id;
    private String account;
    private String userName;
    private String idCard;
    private String Addr;
}

4. 测试说明，程序封装200000个UserDto对象，测试10次。
5. 序列化测试（Object转Json）

工具	次数	毫秒
jackson	第1次	598
jackson	第2次	533
jackson	第3次	510
jackson	第4次	558
jackson	第5次	503
jackson	第6次	507
jackson	第7次	490
jackson	第8次	503
jackson	第9次	523
jackson	第10次	527

6. 反序列化测试（Json转Object）

工具	次数	毫秒
jackson	第1次	412
jackson	第2次	374
jackson	第3次	276
jackson	第4次	316
jackson	第5次	311
jackson	第6次	311
jackson	第7次	327
jackson	第8次	318
jackson	第9次	317
jackson	第10次	304

小结

1. 序列化比较结果（Object转Json）

工具	次数据	最快	最慢	平均
gson	10	468	696	552.5
fastjson	10	632	817	689.6
jackson	10	276	490	598

2. 反序列化比较结果（Json转Object）

工具	次数据	最快	最慢	平均
gson	10	289	357	313.8
fastjson	10	140	179	155
jackson	10	276	412	326.6

3. 结论
   序列化，三个工具类都差不多；反序列化fastjson很出色。所以以后在项目中直接使用fastjson工具类即可。