FastJson2JsonRedisSerializer 和Jackson2JsonRedisSerializer 性能 fastjson json和jsonobject

转载

detailtoo 2024-04-24 23:28:08

文章标签 json java javascript ViewUI List 文章分类 Redis 数据库

背景：

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();
    }
  }
}

运行结果：

FastJson2JsonRedisSerializer 和Jackson2JsonRedisSerializer 性能 fastjson json和jsonobject_javascript

一个含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();
    }
  }

}

运行结果：

FastJson2JsonRedisSerializer 和Jackson2JsonRedisSerializer 性能 fastjson json和jsonobject_javascript_02

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 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://www.json.org.cn/index.htm
http://www.360doc.cn/article/203871_329189269.html

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：ES7 获取的单节点 shards 数量最大限制 elasticsearch单节点配置

下一篇：浏览器request python 浏览器大全

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

FastJson2JsonRedisSerializer 和Jackson2JsonRedisSerializer 性能 fastjson json和jsonobject

FastJson2JsonRedisSerializer 和Jackson2JsonRedisSerializer 性能 fastjson json和jsonobject

51CTO博客