Java序列化与JSON序列化大比拼

原文地址：http://my.oschina.net/noahxiao/blog/112759

一、背景

有项目需要传输Map结构的数据，有人倾向用Java序列化来做，有人倾向用JSON的序列化来做。所以我们还是比比吧。

Java观点：Object2Object，使用时简单快速。

JSON观点：JSON格式与语言无关，扩展性强，速度也应该不慢。

大家可能对Java序列化都有一个错误的认识，认为Java序列化比JSON的序列化效率高并且序列化的数据小，其实实际上并不一定是这样，我这次就想通过实际测试来解开这个谜团。

二、测试方式

测试同一个Map<String,Object>并序列化为byte[]，并再将byte[]反序列化为Map<String,Object>的过程。Object中包括String，Integer，Long，Boolean，Float，Double常规类型的数据。

序列化：Map<String,Object> -> byte[]

反序列化：byte[] -> Map<String,Object>

测试各种大小不同的Map，并循环执行同一操作N次，来得到一个相对稳定的线性结果。

三、比较的对象

JAVA:

手写Java(1.6.0_32)与Common Lang3(3.1)的SerializationUtils。

JSON:

将采用Gson(2.2.2)与json-smart(2.0-RC2)两种不同的JSON解析器。json-smart号称是速度最快的JSON解析器。

四、比较结果

Map大小（10-100）循环10万次

序列化时间比较(y为序列化时间ms)

反序列化时间比较(y为反序列化时间ms)

序列化时间汇总比较(y为序列化与反序列化总时间ms)

序列化后byte大小比较(由于同类线重合显示为2条线)

Map大小（100-1000）循环1万次

序列化时间比较(y为序列化时间ms)

反序列化时间比较(y为反序列化时间ms)

序列化时间汇总比较(y为序列化与反序列化总时间ms)

序列化后byte大小比较(由于同类线重合显示为2条线)

比较总结

Map在小于100时：
Java的反序列化时的性能要比Java序列化时性能差很多，1.5倍左右差距。
JSON序列化性能明显由于Java序列化性能，尤其是反序列化过程。并且序列化后的数据大小也是JSON格式的小。

Map在大于100小于1000时：
Java的反序列化时的性能并没有随Map的大小变化而变差。
JSON阵营中Gson在序列化过程中，比Java只快了那么一点点。在反序列化过程中Gson开始领先与Java，但在Map的大小过700多以后，Gson的反序列化性能比Java要慢。但JSON阵营中的json-smart依然表现出色完全是两个级别。

并不是Java的序列化速度总是最快体积最小，Java需要考虑对象类型，属性类型与内部对象信息等一系列对数据本身并不相关的内容的处理。JSON以固定的格式，稳定简单的数据结构大大简化了序列化过程，虽然也要创建新的Java数据对象但并不会比Java反序列化的速度慢。

从测试结果上看JSON的json-smart更适合项目的需要。

五、测试代码源码

SerializationTest接口

01 package org.noahx.javavsjson;
02
03 import java.util.Map;
04
05 /**
06  * Created with IntelliJ IDEA.
07  * User: noah
08  * Date: 3/8/13
09  * Time: 9:59 PM
10  * To change this template use File | Settings | File Templates.
11  */
12 public interface SerializationTest {
13
14     public String getTestName();
15
16     public Map<String, Object> testBytes2Map(byte[] bytes);
17
18     public byte[] testMap2Bytes(Map<String, Object> map);
19 }

JavaSerializationTest

01 package org.noahx.javavsjson;
02
03 import java.io.*;
04 import java.util.Map;
05
06 /**
07  * Created with IntelliJ IDEA.
08  * User: noah
09  * Date: 3/8/13
10  * Time: 10:05 PM
11  * To change this template use File | Settings | File Templates.
12  */
13 public class JavaSerializationTest implements SerializationTest {
14
15     @Override
16     public String getTestName() {
17         return "Java";
18     }
19
20     @Override
21     public Map<String, Object> testBytes2Map(byte[] bytes) {
22         Map<String, Object> result = null;
23         try {
24             ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
25             ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
26
27             result = (Map<String, Object>) inputStream.readObject();
28             inputStream.close();
29         } catch (ClassNotFoundException e) {
30             e.printStackTrace();
31         } catch (IOException e) {
32             e.printStackTrace();
33         }
34
35         return result;
36     }
37
38     @Override
39     public byte[] testMap2Bytes(Map<String, Object> map) {
40         byte[] bytes = null;
41         try {
42             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
43             ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
44
45             outputStream.writeObject(map);
46             outputStream.close();
47
48             bytes = byteArrayOutputStream.toByteArray();
49         } catch (IOException e) {
50             e.printStackTrace();
51         }
52         return bytes;
53     }
54 }

CommonLang3SerializationTest

01 package org.noahx.javavsjson;
02
03 import org.apache.commons.lang3.SerializationUtils;
04
05 import java.io.Serializable;
06 import java.util.Map;
07
08 /**
09  * Created with IntelliJ IDEA.
10  * User: noah
11  * Date: 3/9/13
12  * Time: 2:24 AM
13  * To change this template use File | Settings | File Templates.
14  */
15 public class CommonLang3SerializationTest implements SerializationTest {
16     @Override
17     public String getTestName() {
18         return "Commons Lang3";
19     }
20
21     @Override
22     public Map<String, Object> testBytes2Map(byte[] bytes) {
23         return (Map<String, Object>) SerializationUtils.deserialize(bytes);
24     }
25
26     @Override
27     public byte[] testMap2Bytes(Map<String, Object> map) {
28         return SerializationUtils.serialize((Serializable) map);
29     }
30 }

GsonSerializationTest

01 package org.noahx.javavsjson;
02
03 import com.google.gson.Gson;
04
05 import java.io.UnsupportedEncodingException;
06 import java.util.Map;
07
08 /**
09  * Created with IntelliJ IDEA.
10  * User: noah
11  * Date: 3/8/13
12  * Time: 10:02 PM
13  * To change this template use File | Settings | File Templates.
14  */
15 public class GsonSerializationTest implements SerializationTest {
16
17     private Gson gson;
18
19     public GsonSerializationTest() {
20         gson = new Gson();
21     }
22
23     @Override
24     public String getTestName() {
25         return "Gson";
26     }
27
28     @Override
29     public Map<String, Object> testBytes2Map(byte[] bytes) {
30         Map<String, Object> result = null;
31         try {
32             result = gson.fromJson(new String(bytes, "UTF-8"), Map.class);
33         } catch (UnsupportedEncodingException e) {
34             e.printStackTrace();
35         }
36         return result;
37     }
38
39     @Override
40     public byte[] testMap2Bytes(Map<String, Object> map) {
41         String str = gson.toJson(map);
42         byte[] bytes = null;
43         try {
44             bytes = str.getBytes("UTF-8");
45         } catch (UnsupportedEncodingException e) {
46             e.printStackTrace();
47         }
48         return bytes;
49     }
50 }

JsonSmartSerializationTest

01 package org.noahx.javavsjson;
02
03 import net.minidev.json.JSONObject;
04 import net.minidev.json.JSONValue;
05 import net.minidev.json.parser.ParseException;
06
07 import java.io.UnsupportedEncodingException;
08 import java.util.Map;
09
10 /**
11  * Created with IntelliJ IDEA.
12  * User: noah
13  * Date: 3/9/13
14  * Time: 1:30 AM
15  * To change this template use File | Settings | File Templates.
16  */
17 public class JsonSmartSerializationTest implements SerializationTest {
18     @Override
19     public String getTestName() {
20         return "Json Smart";
21     }
22
23     @Override
24     public Map<String, Object> testBytes2Map(byte[] bytes) {
25         Map<String, Object> map = null;
26         try {
27             map = (Map<String, Object>) JSONValue.parseStrict((new String(bytes, "UTF-8")));
28         } catch (ParseException e) {
29             e.printStackTrace();
30         } catch (UnsupportedEncodingException e) {
31             e.printStackTrace();
32         }
33         return map;
34     }
35
36     @Override
37     public byte[] testMap2Bytes(Map<String, Object> map) {
38         String str = JSONObject.toJSONString(map);
39         byte[] result = null;
40         try {
41             result = str.getBytes("UTF-8");
42         } catch (UnsupportedEncodingException e) {
43             e.printStackTrace();
44         }
45         return result;
46     }
47 }

源码下载：http://sdrv.ms/12ECmgG

P.S.

我也测试过Map<String,String>固定数据类型value只为String的情况，这时Java与JSON的性能的差距会减小，但JSON序列化性能与数据大小还是占优势，尤其是反序列化的速度JSON更出色。

Gson在数值反序列化后，因为Object无法确定类型，Map中的Long，Integer，Float统一转为了Double类型。
json