第一部分:序列化测试
首先说一下结论。
1. 序列化测试结论
100个对象转换,gson最快、fastjson其次、jackson最差 b.
10000个对象转换,gson和fastjson耗时几乎一样,jackson最差
100000个对象转换,fastjson最快、jackson其次、gson最差
2. 建议
数据处理量小的情况下使用gson,数据量大的情况下使用fastjson。
具体测试过程如下
1. pom.xml依赖如下
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.31</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.8.5</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.7.3</version>
</dependency>
2:序列化测试代码
/**
* 测试fastjson gson jackson性能
*/
@Test
public void test1() throws JsonProcessingException {
List<User> users = new ArrayList<User>();
for (int i = 0; i < 100; i++) {
User user = new User();
user.setId(i);
user.setUsername("张三"+i);
user.setBirthday(new Date());
users.add(user);
}
//测试gson用时
Gson gson = new Gson();
long start = new Date().getTime();
gson.toJson(users);
long end = new Date().getTime();
System.out.println("gson转换共用时:"+(end-start)+"ms");
//测试fastjson用时
long start1 = new Date().getTime();
JSON.toJSONString(users);
long end1 = new Date().getTime();
System.out.println("fastjson转换共用时:"+(end1-start1)+"ms");
//测试jackson用时
long start2 = new Date().getTime();
ObjectMapper mapper = new ObjectMapper();
mapper.writeValueAsString(users);
long end2 = new Date().getTime();
System.out.println("jackson转换共用时:"+(end2-start2)+"ms");
}
3. 测试结果
- 100个对象(测试3次结果)
- 第一次结果
- 第二次结果
- 第三次结果
- 第一次结果
- 10000个对象
- 第一次结果
- 第二次结果
- 第三次结果
- 第一次结果
- 100000个对象
- 第一次结果
- 第二次结果
- 第三次结果
- 第一次结果
4. 测试结论
100个对象转换,gson最快、fastjson其次、jackson最差 b.
10000个对象转换,gson和fastjson耗时几乎一样,jackson最差
100000个对象转换,fastjson最快、jackson其次、gson最差
5. 建议
数据处理量小的情况下使用gson,数据量大的情况下使用fastjson
第二部分:反序列化测试
代码和测试数据如下
/**
* 测试gson反序列化
*
* 测试结果如下:
* 1000000对象:
* 第一次4131ms
* 第二次4225ms
* 第三次4345ms
* 10000个对象:
* 第一次77ms
* 第二次78ms
* 第三次71ms
*/
@Test
public void testGsonDeserialization() {
try {
BufferedReader reader = new BufferedReader(new FileReader("f:/json1.json"));
String json = reader.readLine();
// 测试gson的反序列化
Gson gson = new Gson();
long start = new Date().getTime();
List<User> list = gson.fromJson(json, List.class);
long end = new Date().getTime();
System.out.println("使用gson:反序列化对象数目:" + list.size() + ", 用时:" + (end - start));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 测试fastjson反序列化
*
* 测试结果如下:
* 1000000对象:
* 第一次3679ms
* 第二次3783ms
* 第三次2972ms
* 10000对象:
* 第一次247ms
* 第二次229ms
* 第三次240ms
*/
@Test
public void testFastJsonDeserialization(){
try {
BufferedReader reader = new BufferedReader(new FileReader("f:/json1.json"));
String json = reader.readLine();
// 测试fastjson反序列化
long start1 = new Date().getTime();
List<User> list1= (List<User>) JSON.parse(json);
long end1 = new Date().getTime();
System.out.println("使用fastjson:反序列化对象数目:"+list1.size()+", 用时:"+(end1-start1));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 测试jackson反序列化
*
* 测试结果如下:
* 1000000个对象:
* 第一次4239ms
* 第二次4209ms
* 第三次3671ms
* 10000个对象:
* 第一次107ms
* 第二次114ms
* 第三次122ms
*/
@Test
public void testJacksonDeserialization(){
try {
BufferedReader reader = new BufferedReader(new FileReader("f:/json1.json"));
String json = reader.readLine();
// 测试jackson反序列化
ObjectMapper objectMapper = new ObjectMapper();
long start2 = new Date().getTime();
List<User> list2 = objectMapper.readValue(json, List.class);
long end2 = new Date().getTime();
System.out.println("使用jackjson:反序列化对象数目:" + list2.size() + ", 用时:" + (end2 - start2));
} catch (IOException e) {
e.printStackTrace();
}
}