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
posted @ 2018-08-24 15:18 左手背右手背 阅读(...) 评论(...) 编辑 收藏