Jackson和fastjson簡單用法及性能對比

時間 2019-11-13

原文原文鏈接

背景：html

Java處理JSON數據有三個比較流行的類庫FastJSON、Gson和Jackson。fastjson是阿里作的國有開源Java工具包，jackson是spring mvc內置的json轉換工具，孰強孰弱呢？java

1 Json基本介紹spring

JSON的全稱是」JavaScript Object Notation」，意思是JavaScript對象表示法，它是一種基於文本，獨立於語言的輕量級數據交換格式。

1.1 Json兩種結構json

JSON有兩種表示結構，對象和數組。
對象結構以」{」大括號開始，以」}」大括號結束。中間部分由0或多個以」，」分隔的」key(關鍵字)/value(值)」對構成，關鍵字和值之間以」：」分隔，語法結構如代碼。數組

{
    key1:value1,
    key2:value2,
    ...
}

其中關鍵字是字符串，而值能夠是字符串，數值，true,false,null,對象或數組。mvc

數組結構以」[」開始，」]」結束。中間由0或多個以」，」分隔的值列表組成，語法結構如代碼。app

[
    {
        key1:value1,
        key2:value2 
    },
    {
         key3:value3,
         key4:value4   
}
]

1.2字符串和Json表示方式maven

字符串：指使用「」雙引號或’’單引號包括的字符。
例如：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