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

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

• 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 main.java.jackson;public class User {     private String username;     private Integer age;     public String getUsername() {      return username;     }     public void setUsername(String username) {      this.username = username;     }     public Integer getAge() {      return age;     }     public void setAge(Integer age) {      this.age = age;     } }

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

package main.java.jackson;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import org.codehaus.jackson.map.ObjectMapper;public class BeanToJson {     public static void main(String[] args) throws Exception {          //将对象转换成json字符串      User user = new User();      user.setAge(10);      user.setUsername("jzx");      ObjectMapper objectMapper = new ObjectMapper();      String userJson = objectMapper.writeValueAsString(user);      System.out.println(userJson);      //打印：{"username":"jzx","age":10}      //将list集合对象转换成json字符串      User user1 = new User();      user1.setAge(11);      user1.setUsername("sss");      User user2 = new User();      user2.setAge(12);      user2.setUsername("hsj");      List<User> userList = new ArrayList<User>();      userList.add(user1);      userList.add(user2);      String userListJson = objectMapper.writeValueAsString(userList);      System.out.println(userListJson);      //打印结果：[{"username":"sss","age":11},{"username":"hsj","age":12}]      //将map集合转换成json字符串。      Map<String,User> userMap = new HashMap<String,User>();      userMap.put("user1", user1);      userMap.put("user2", user2);      String userMapJson  = objectMapper.writeValueAsString(userMap);      System.out.println(userMapJson);      //打印结果：{"user2":{"username":"hsj","age":12},"user1":{"username":"sss","age":11}}     }}

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

package main.java.jackson;import java.util.List;public class ListBean {     List<User> userList;     public List<User> getUserList() {      return userList;     }     public void setUserList(List<User> userList) {      this.userList = userList;     } }json字符串转换成java对象（反序列化）package main.java.jackson;import java.util.List;import java.util.Map;import org.codehaus.jackson.map.ObjectMapper;public class JsonToBeans {     public static void main(String[] args) throws Exception {          //将json字符串转换成java对象          String userJson = "{\"username\":\"jzx\",\"age\":10}";          ObjectMapper objectMapper = new ObjectMapper();          User user = objectMapper.readValue(userJson,User.class);          System.out.println(user+":"+user.getUsername()+","+ user.getAge());          //打印结果：com.Jtianlin.test.User@c2a132:jzx,10          //将json字符串数组转换成java对象list集合。直接转换成list集合较为复杂，本例通过一个过渡对象          //该对象里面存有一个list的java对象集合。通过转换成对象来实现集合对象的转换。          String userListJson = "{\"userList\":[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]}";          ListBean listBeans = objectMapper.readValue(userListJson, ListBean.class);          System.out.println(listBeans.getUserList());          //打印结果：[com.Jtianlin.test.User@1e0bc08, com.Jtianlin.test.User@158b649]          //将json字符串转换成map集合，可以通过键来取得值。          String mapJson = "{\"username\":\"hsj\",\"age\":12}";          Map userMap = objectMapper.readValue(mapJson, Map.class);          System.out.println(userMap+":" + userMap.get("username")+","+userMap.get("age") );          //打印结果：{username=hsj, age=12}:hsj,12          //将json字符串数组转换成Map的list集合。          String json ="[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]";          List<Map> list = objectMapper.readValue(json, List.class);            System.out.println(list.get(0).get("username"));          //打印结果：sss     }}

同时jackson还能使用注解实现配置一些功能，这一部分可以另行查阅。

• 2.2 fastjson使用

  fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。主要特点：

  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 main.java.fastjson;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import main.java.jackson.User;import com.alibaba.fastjson.JSON;public class BeanToJson {     public static void main(String[] args) throws Exception {          //将对象转换成json字符串      User user = new User();      user.setAge(10);      user.setUsername("jzx");      String userJson = JSON.toJSONString(user);      System.out.println(userJson);      //打印：{"age":10,"username":"jzx"}      //将list集合对象转换成json字符串      User user1 = new User();      user1.setAge(11);      user1.setUsername("sss");      User user2 = new User();      user2.setAge(12);      user2.setUsername("hsj");      List<User> userList = new ArrayList<User>();      userList.add(user1);      userList.add(user2);      String userListJson = JSON.toJSONString(userList);      System.out.println(userListJson);      //打印结果：[{"age":11,"username":"sss"},{"age":12,"username":"hsj"}]      //将map集合转换成json字符串。      Map<String,User> userMap = new HashMap<String,User>();      userMap.put("user1", user1);      userMap.put("user2", user2);      String userMapJson  = JSON.toJSONString(userMap);      System.out.println(userMapJson);      //打印结果：{"user2":{"age":12,"username":"hsj"},"user1":{"age":11,"username":"sss"}}     }}

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

package main.java.fastjson;import java.util.List;import java.util.Map;import main.java.jackson.ListBean;import main.java.jackson.User;import com.alibaba.fastjson.JSON;public class JsonToBeans {     public static void main(String[] args) throws Exception {          //将json字符串转换成java对象          String userJson = "{\"username\":\"jzx\",\"age\":10}";          User user = JSON.parseObject(userJson,User.class);          System.out.println(user+":"+user.getUsername()+","+ user.getAge());          //打印结果：main.java.jackson.User@1de06d7e:jzx,10          //将json字符串数组转换成java对象list集合。直接转换成list集合较为复杂，本例通过一个过渡对象          //该对象里面存有一个list的java对象集合。通过转换成对象来实现集合对象的转换。          String userListJson = "{\"userList\":[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]}";          ListBean listBeans =JSON.parseObject(userListJson, ListBean.class);          System.out.println(listBeans.getUserList());          //打印结果：[main.java.jackson.User@6273e11a, main.java.jackson.User@25bfa475]          //将json字符串转换成map集合，可以通过键来取得值。          String mapJson = "{\"username\":\"hsj\",\"age\":12}";          Map userMap = JSON.parseObject(mapJson, Map.class);          System.out.println(userMap+":" + userMap.get("username")+","+userMap.get("age") );          //打印结果：{username=hsj, age=12}:hsj,12          //将json字符串数组转换成Map的list集合。          String json ="[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]";          List<Map> list = JSON.parseObject(json, List.class);           System.out.println(list.get(0).get("username"));          //打印结果：sss     }}

fastjson还能使用注解实现配置一些功能，这一部分可以另行查阅。

• 3 Jackson和fastson性能对比

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

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

          long startTime = System.currentTimeMillis();    //获取开始时间          for(int i=0;i<100;i++){              userJson = JSON.toJSONString(user);//user: {"age":10,"username":"jzx"}              //userJson = 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                100000Jackson      50|47|47        65|63|64      214|216|221          375|377|381Fastjson     93|92|91        104|101|99    193|197|200          321|330|311

[{“age”:11,”username”:”sss”},{“age”:12,”username”:”hsj”}],将list集合对象转换成json字符串

          long startTime = System.currentTimeMillis();    //获取开始时间          for(int i=0;i<100000;i++){              userListJson = JSON.toJSONString(userList);              //userListJson = objectMapper.writeValueAsString(userList);          }           long endTime = System.currentTimeMillis();    //获取结束时间                System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

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

Json库      100          1000         10000          100000Jackson    59|60|61     84|79|82     219|222|202    382|371|398Fastjson   97|101|90    121|123|121  275|263|275    366|369|375

{"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");    //输出程序运行时间

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

Json库        100        1000         10000          100000Jackson     57|56|53    92|99|98     237|238|227    431|437|444Fastjson    96|91|92    129|129|124  282|280|276    374|362|372

由此结果可知，序列化时，在少量数据时，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）：

Json库       100         1000          10000         100000Jackson     48|51|47    73|77|76      350|355|364   523|526|526Fastjson    95|93|95    133|127|127   306|304|308   413|429|422

{\"userList\":[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]}，将json字符串数组转换成java对象list集合：

          String userListJson = "{\"userList\":[{\"username\":\"sss\",\"age\":11},{\"username\":\"hsj\",\"age\":12}]}";          ListBean listBeans = null;          long startTime = System.currentTimeMillis();    //获取开始时间          for(int i=0;i<100;i++){              listBeans =JSON.parseObject(userListJson, ListBean.class);              //listBeans = objectMapper.readValue(userListJson, ListBean.class);          }           long endTime = System.currentTimeMillis();    //获取结束时间                System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

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

Json库      100          1000          10000         100000Jackson    64|61|56     120|115|110   343|344|348   554|540|546Fastjson   105|104|102  155|158|156   374|367|377   481|487|469

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

          String mapJson = "{\"username\":\"hsj\",\"age\":12}";          Map userMap = null;          long startTime = System.currentTimeMillis();    //获取开始时间          for(int i=0;i<100;i++){              userMap = JSON.parseObject(mapJson, Map.class);              //userMap = objectMapper.readValue(mapJson, Map.class);          }           long endTime = System.currentTimeMillis();    //获取结束时间                System.out.println("程序运行时间fastjson：" + (endTime - startTime) + "ms");    //输出程序运行时间

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

Json库        100         1000           10000       100000Jackson     44|44|39    85|87|80       391|381|382  469|484|476Fastjson    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