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

最新推荐文章于 2024-05-23 09:55:25 发布
最新推荐文章于 2024-05-23 09:55:25 发布
阅读量5.6k 收藏 2
点赞数
分类专栏： json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moyu_2012/article/details/49719321
版权

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                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

[{“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          100000
Jackson    59|60|61     84|79|82     219|222|202    382|371|398
Fastjson   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          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
由此结果可知，序列化时，在少量数据时，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         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
{\"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         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
{\"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       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

默于
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
gson,fastjson,jackson简单使用
08-13
对比这三大库，Gson通常被认为是最简单的，而Fastjson以其速度和易用性受到青睐。Jackson则以其丰富的特性和灵活性而闻名，例如支持注解来定制序列化和反序列化的规则。 在实际开发中，选择哪个库取决于具体需求。...
springboot整合Jackson实例项目-附工具类
03-21
Jackson 运行时占用内存比较低，性能比较好；Jackson 有灵活的 API，可以很容易进行扩展和定制。 额外了解： Jackson 的 1.x 版本的包名是 org.codehaus.jackson ， 当升级到 2.x 版本时，包名变为...
fastjson改造，fastjson转jackson（真实项目案例，主要提供思路）
ponymate的博客
03-14 1334
目前项目中大量的代码均使用了fastjson和json-lib两种框架（主要是fastjson），总计超过200个类中使用了这两种框架，且fastjson的代码api和jackson的相差较大，逐一改造十分困难，改造量巨大，想要改造的话需要先熟悉一下这两种框架，下面是二者的对比。的主要功能是进行数据之间的格式转化，即json字符串、具体的业务对象、json对象（JsonNode及其实现类）这三种数据之间的转化，其中json字符串和具体业务对象之间的转化比较简单，中数据的类型进行了类型的限制。
FastJson和Jackson
晏的博客
03-16 400
FastJson和Jackson
FastJSON2 ＞ FastJSON 好在何处
最新发布
新生代码农的博客
05-23 1490
FastJSON2在性能、安全性、功能、兼容性和内存管理等方面相比 FastJSON 都有显著的提升。对于需要高性能 JSON 解析和序列化的应用场景，特别是在安全性要求较高的情况下，FastJSON2 是一个更好的选择。通过本文的介绍，希望开发者能够更好地理解和利用 FastJSON2 提供的优势，为项目带来更高的性能和安全性。选择 FastJSON2 可以带来如下主要优势：更高的性能：优化的序列化和反序列化算法，提高了处理速度。更强的安全性：增强的黑名单机制和类型检测，确保数据解析的安全。
放弃FastJson！一篇就够，Jackson的功能原来如此之牛（万字干货）
程序新视界
02-24 7197
在上篇《经过多方调研，最终还是决定禁用FastJson！》中，讲了FastJson的基本使用以及存在的不确定性问题，所以最终决定在项目中放弃使用，进而选择市面上比较主流，Spring Boot默认绑定的JSON类库：Jackson。 本文就来讲解一下Jackson的基本使用以及与Spring Boot的结合与实践。 什么是Jackson Jackson是比较主流的基于Java的JSON类库，可用于Json和XML与JavaBean之间的序列化和反序列化。 没看错，Jackson也可以处理JavaBean与X
fastjson和jackson
qq_16268979的博客
04-06 827
作为以为搬砖人，JSON一直是我们绕不开的话题，这里篇文章就主要介绍下我们常见的Java处理JSON的类库fastjson和jackson。 一、JSON 1.概念 JSON: JavaScript Object Notation(JavaScript 对象表示法)。JSON 是存储和交换文本信息的语法，类似 XML。JSON 比 XML 更小、更快，更易解析。 2.什么是 JSON ？ JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation） JSON 是
fastjson和Jackson对比
enjoy.day
01-15 1500
测试代码 @Test public void TestJsonSpeed(){ try { Map<String, Object> map = new HashMap<>(); for (int i = 0; i< 100000; i++){ map.p...
fastjson使用
01-20
在本教程中，我们将深入探讨Fastjson的基本用法，包括序列化和反序列化。 ### 1. **序列化** **序列化**是指将Java对象转换为JSON字符串的过程。在Fastjson中，这一过程非常简单。假设我们有一个名为`User`的类： ...
java中Json工具的用法与性能测试
07-07
在Java开发中，JSON（JavaScript ...以上就是关于Java中Fastjson、Jackson、Gson和json-lib这四个JSON工具的用法及性能测试的基本介绍。理解它们的特性可以帮助开发者更有效地处理JSON数据，提高项目的效率和质量。
FastJsonTest.zip
05-31
相较于其他流行的JSON库，如Jackson和Gson，FastJson在速度上往往更具优势，但在某些复杂场景下，可能需要权衡性能和灵活性。 总的来说，FastJson凭借其出色的性能和丰富的功能，成为了Java开发者处理JSON数据的...
fastjson与jackson的性能比较
08-07
NULL 博文链接：https://gyx001.iteye.com/blog/2106364
各个JSON技术的比较
weixin_34210740的博客
09-30 1493
JSON技术的调研报告一 、各个JSON技术的简介和优劣1.json-libjson-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph...
fastJson与jackson性能对比
Belief的编码生涯
09-30 3万+
最近项目用到fastJson和jackson，为了决定到底弃用哪个，随手写了个测试看看到底谁的性能更胜一筹。 看到过很多对比的帖子，大多数结果是fastJson性能高于jackson，可偏偏像SpringMVC这样成熟的框架默认也采用的jsckson，这就引起了我的怀疑，决定自己动手试试 1、开始测试，用一个map往里面装10万个键值对，结果jackson速度快于fastjson，jackso...
fastJson和jackson转json的区别
Thancks
12-02 1万+
首先举个fastJson和jackson转json的例子，然后对比两种的区别 例子1：{ "statusCode": 800, "returnObj": { "hzOrderId": 14, "orderId": 2015111311521900000, "orderSendPlanId": 67 } }
fastjson和jackson序列化数据的区别
weixin_38381149的博客
03-28 2687
用了很久的fastjson和jackson， 一直没去想他们的区别， 今天写了个小栗子，来分析一下
使用FastJson对JSON字符串、JSON对象及JavaBean之间的相互转换
热门推荐
xuforeverlove的博客
06-28 34万+
maven依赖包： <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> ...
fastjson 进行json的解析和拼装和用ObjectMapper序列化和反序列化
清宵尚温的博客
11-03 1981
ObjectMapper中writeValue和writeValueAsString的使用方法 writeValue（参数，obj）： 参数： File： 将对象转为json字符串，保存到指定的文件中 Writer： 将对象转为json字符串，并将json数据填充到字符输出流中 outputStream： 将对象转为json字符串，并将json数据填充到字节输出流中 writeValueAsStr...
FASTJSON和JACKSON基本使用
少年啦飞啦的博客
10-23 1086
Json是一种轻量级的数据交换格式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据过程中常常被使用，是一种理想的数据交换语言。在使用Java做Web开发时，不可避免的会遇到Json的使用。 JSON形式与语法 JSON对象 我们先来看以下数据： { "ID": 1001, "name": "张三", "age": 24 } 这个数据就是一个Jso...
jackson和fastjson区别
08-18
总的来说，Jackson和Fastjson都是优秀的JSON处理库，选择哪个库取决于项目的具体需求和性能要求。如果对性能要求较高且需要更多的定制化能力，可以考虑使用Fastjson。如果项目已经集成了许多基于Jackson的库或框架，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值