Jackson和fastjson简单用法及性能对比

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

背景：

Java处理JSON数据有三个比较流行的类库FastJSON、Gson和Jackson。fastjson是阿里做的国有开源Java工具包，jackson是spring mvc内置的json转换工具，孰强孰弱呢？

1 Json基本介绍

JSON的全称是”JavaScript Object Notation”，意思是JavaScript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式。

1.1 Json两种结构

JSON有两种表示结构，对象和数组。
对象结构以”{”大括号开始，以”}”大括号结束。中间部分由0或多个以”，”分隔的”key(关键字)/value(值)”对构成，关键字和值之间以”：”分隔，语法结构如代码。

{

    key1:value1,

    key2:value2,

    ...

}

其中关键字是字符串，而值可以是字符串，数值，true,false,null,对象或数组。

数组结构以”[”开始，”]”结束。中间由0或多个以”，”分隔的值列表组成，语法结构如代码。

[

    {

        key1:value1,

        key2:value2

    },

    {

         key3:value3,

         key4:value4

}

]

1.2字符串和Json表示方式

字符串：指使用“”双引号或’’单引号包括的字符。
例如：var comStr = ‘this is string’;
json字符串：指的是符合json格式要求的js字符串。
例如：var jsonStr = “{StudentID:’100’,Name:’tmac’,Hometown:’usa’}”;
json对象：指符合json格式要求的js对象。
例如：var jsonObj = { StudentID: “100”, Name: “tmac”, Hometown: “usa” };
2 几种简单的Json库使用方式
2.1 jackson使用

使用的jar包：
jackson-mapper-asl-1.8.11.jar
jackson-core-2.5.1.jar
jackson-databind-2.4.5.jar
也可是使用maven源配置。
一个简单的bean类：

package com.mmall.pojo;

import lombok.Data;

/**

 * Created by sww_6 on 2018/8/24.

 */

@Data

public class Users {

  private String username;

  private Integer age;

}

java对象到json字符串（序列化）：

package com.mmall.common;

import com.mmall.pojo.Users;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.codehaus.jackson.map.ObjectMapper;

/**

 * Created by sww_6 on 2018/8/24.

 */

public class BeanToJson {

  public static void main(String[] args) {

    //将对象转成json字符串

    Users users = new Users();

    users.setAge(18);

    users.setUsername("魏璎珞");

    ObjectMapper objectMapper = new ObjectMapper();

    try {

      String jsonString = objectMapper.writeValueAsString(users);

      System.out.println(jsonString);

    } catch (IOException e) {

      e.printStackTrace();

    }

    //将list集合转换成json字符串

    Users user2 = new Users();

    user2.setAge(18);

    user2.setUsername("沉壁");

    Users user3 = new Users();

    user3.setAge(18);

    user3.setUsername("永琪");

    List<Users> jsonList = new ArrayList<>();

    jsonList.add(user2);

    jsonList.add(user3);

    try {

      String list = objectMapper.writeValueAsString(jsonList);

      System.out.println(list);

    } catch (IOException e) {

      e.printStackTrace();

    }

    //将map集合转换成json字符串

    Map<String, Users> map = new HashMap();

    map.put("user2", user2);

    map.put("user3", user3);

    try {

      String mapJson = objectMapper.writeValueAsString(map);

      System.out.println(mapJson);

    } catch (IOException e) {

      e.printStackTrace();

    }

  }

}

运行结果：

一个含java对象集合变量的类，用于json字符串数组到对象集合：

package com.mmall.common;

import com.mmall.pojo.Users;

import java.io.IOException;

import java.util.List;

import java.util.Map;

import org.codehaus.jackson.map.ObjectMapper;

/**

 * Created by sww_6 on 2018/8/24.

 */

public class JsonToBeans {

  public static void main(String[] args) {

    //将json字符串转化为java对象

    String userJson = "{\"username\":\"福康安\",\"age\":18}";

    ObjectMapper objectMapper = new ObjectMapper();

    try {

      Users users = objectMapper.readValue(userJson, Users.class);

      System.out.println(users + ":" + users.getUsername() + "," + users.getAge());

    } catch (IOException e) {

      e.printStackTrace();

    }

    //将json字符串转化成java的list集合

    String jsonList = "{\"userList\":[{\"username\":\"永基\",\"age\":18},{\"username\":\"永荣\",\"age\":18}]}";

    try {

      ListBean listBean = objectMapper.readValue(jsonList, ListBean.class);

      System.out.println(listBean.getUserList());

    } catch (IOException e) {

      e.printStackTrace();

    }

    //将json转化成java的map集合

    String jsonMap = "{\"username\":\"五阿哥\",\"age\":18}";

    try {

      Map map = objectMapper.readValue(jsonMap, Map.class);

      System.out.println(map + ":" + map.get("username") + "," + map.get("age"));

    } catch (IOException e) {

      e.printStackTrace();

    }

    //将json字符串数组转换成Map的list集合。

    String json = "[{\"username\":\"傅恒\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]";

    try {

      List<Map> list = objectMapper.readValue(json, List.class);

      System.out.println(list.get(0).get("username"));

    } catch (IOException e) {

      e.printStackTrace();

    }

  }

}

运行结果：

2.2 fastjson使用
```
fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。主要特点：
```
- 1
- 2
a) 快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）
b) 强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）
c) 零依赖（没有依赖其它任何类库除了JDK）
2.2.1fastjson生成json字符串

(JavaBean,List<JavaBean>,List<String>,List<Map<String,Object>)

 String jsonStrng = JSON.toJSONString(object);

2.2.2fastjson 解析json字符串为四种类型

1. JavaBean

          Person person = JSON.parseObject(jsonString, Person.class);

      2. List<JavaBean>

          List<Person> listPerson =JSON.parseArray(jsonString, Person.class);

      3. List<String>

          List<String> listString = JSON.parseArray(jsonString, String.class);

      4. List<Map<String,Object>>

          List<Map<String, Object>> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map<String,Object>>>(){});

2.2.3实现测试

需要的jar包fastjson-1.2.5.jar，也可以maven配置。
java对象到json字符串（序列化）：（采用jackson下的user和listbean类）

package com.yongjun.stock.controller;

import com.alibaba.fastjson.JSON;

import com.yongjun.stock.model.dto.Users;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

/**

 * Created by sww_6 on 2018/8/24.

 */

public class BeanToJson {

  public static void main(String[] args) {

//将对象转成json字符串

    Users users = new Users();

    users.setAge(18);

    users.setUsername("魏璎珞");

    String json = JSON.toJSONString(users);

    System.out.println(json);

    //将list集合转换成json字符串

    Users user2 = new Users();

    user2.setAge(18);

    user2.setUsername("沉壁");

    Users user3 = new Users();

    user3.setAge(18);

    user3.setUsername("永琪");

    List<Users> jsonList = new ArrayList<>();

    jsonList.add(user2);

    jsonList.add(user3);

    String jsonLists = JSON.toJSONString(jsonList);

    System.out.println(jsonLists);

    //将map集合转换成json字符串

    Map<String, Users> map = new HashMap();

    map.put("user2", user2);

    map.put("user3", user3);

    String jsonmap = JSON.toJSONString(map);

    System.out.println(jsonmap);

  }

}

运行结果：

json字符串转换成java对象（反序列化）：

package com.yongjun.stock.controller;

import com.alibaba.fastjson.JSON;

import com.yongjun.stock.model.ListBean;

import com.yongjun.stock.model.dto.Users;

import java.util.List;

import java.util.Map;

/**

 * Created by sww_6 on 2018/8/24.

 */

public class JsonToBeans {

  public static void main(String[] args) {

    //将json字符串转化为java对象

    String userJson = "{\"username\":\"福康安\",\"age\":18}";

    Users users = JSON.parseObject(userJson, Users.class);

    System.out.println(users + ":" + users.getUsername() + "," + users.getAge());

    //将json字符串转化成java的list集合

    String jsonList = "{\"userList\":[{\"username\":\"永基\",\"age\":18},{\"username\":\"永荣\",\"age\":18}]}";

    ListBean listBean = JSON.parseObject(jsonList, ListBean.class);

    System.out.println(listBean.getUserList());

    //将json转化成java的map集合

    String jsonMap = "{\"username\":\"五阿哥\",\"age\":18}";

    Map map = JSON.parseObject(jsonMap, Map.class);

    System.out.println(map + ":" + map.get("username") + "," + map.get("age"));

    //将json字符串数组转换成Map的list集合。

    String json = "[{\"username\":\"傅恒\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]";

    List<Map> list = JSON.parseObject(json, List.class);

    System.out.println(list.get(0).get("username"));

  }

}

运行结果：

3 Jackson和fastson性能对比
3.1 java对象到json字符串（序列化）对比：

{“age”:10,”username”:”魏璎珞”},将对象转换成json字符串

package com.yongjun.stock.controller;

import com.alibaba.fastjson.JSON;

import com.yongjun.stock.model.dto.Users;

/**

 * Created by sww_6 on 2018/8/24.

 */

public class BeanToJson {

  public static void main(String[] args) {

   //将对象转成json字符串

    Users users = new Users();

    users.setAge(18);

    users.setUsername("魏璎珞");

    long startTime = System.currentTimeMillis();    //获取开始时间

    for (int i = 0; i < 1000; i++) {

      String s = JSON.toJSONString(users);//user: {"age":10,"username":"jzx"}

      //String s = objectMapper.writeValueAsString(user);

    }

    long endTime = System.currentTimeMillis();    //获取结束时间

    System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

  }

}

试jackson和fastjson序列化消耗时间，选取100,1000,10000，100000进行测试，同样环境每次运行3次，结果如下（ms）：

Json库        100             1000          10000                100000

Jackson      50|47|47        65|63|64      214|216|221          375|377|381

Fastjson     93|92|91        104|101|99    193|197|200          321|330|311

{"user2":{"age":12,"username":"hsj"},"user1":{"age":11,"username":"sss"}}，将map集合转换成json字符串

long startTime = System.currentTimeMillis();    //获取开始时间

          for(int i=0;i<100;i++){

              userMapJson  = JSON.toJSONString(userMap);

              //userMapJson = objectMapper.writeValueAsString(userMap);

          }

          long endTime = System.currentTimeMillis();    //获取结束时间

          System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

Json库        100        1000         10000          100000

Jackson     57|56|53    92|99|98     237|238|227    431|437|444

Fastjson    96|91|92    129|129|124  282|280|276    374|362|372

1

2

3

由此结果可知，序列化时，在少量数据时，jackson性能比fastson要好，当数据量越来越大时，fastson的性能要好于jackson；序列化时选取何种json库，可根据数据多少进行选择。

3.2 json字符串转换成java对象（反序列化）对比：

{\”username\”:\”jzx\”,\”age\”:10}，将json字符串转换成java对象

String userJson = "{\"username\":\"jzx\",\"age\":10}";

          User user =null;

          ObjectMapper objectMapper = new ObjectMapper();

          long startTime = System.currentTimeMillis();    //获取开始时间

          for(int i=0;i<100;i++){

              user  = JSON.parseObject(userJson,User.class);

              //user = objectMapper.readValue(userJson,User.class);

          }

          long endTime = System.currentTimeMillis();    //获取结束时间

          System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

测试jackson和fastjson反序列化消耗时间，选取100,1000,10000，100000进行测试，同样环境每次运行3次，结果如下（ms）：

1

2

Json库       100         1000          10000         100000

Jackson     48|51|47    73|77|76      350|355|364   523|526|526

Fastjson    95|93|95    133|127|127   306|304|308   413|429|422

测试方法相同，结果如下（ms）：

1

2

Json库      100          1000          10000         100000

Jackson    64|61|56     120|115|110   343|344|348   554|540|546

Fastjson   105|104|102  155|158|156   374|367|377   481|487|469

1

2

3

{\"username\":\"hsj\",\"age\":12}，将json字符串转换成map集合：

Json库        100         1000           10000       100000

Jackson     44|44|39    85|87|80       391|381|382  469|484|476

Fastjson    74|71|71    111|111|112    334|297|301  515|502|500

由此结果可知，反序列化时，除在map转化有些不同，在少量数据时，jackson性能比fastson要好，当数据量越来越大时，fastson的性能要好于jackson；序列化时选取何种json库，可根据数据多少进行选择。

同时通过复杂数据进行反序列化测试,测试fastjson和jackson，效果差别则很大，性能差距近乎5倍，   此时，fastjson明显要好于jackson。

参考：
http://blog.csdn.net/wutongyu344/article/details/7321591
http://www.cnblogs.com/goody9807/p/4244862.html
http://www.cnblogs.com/mcgrady/archive/2013/06/08/3127781.html
http://www.json.org.cn/index.htm
http://www.360doc.cn/article/203871_329189269.html