一、背景

有專案需要傳輸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介面

1. package org.noahx.javavsjson;

2.  

3. import java.util.Map;

4.  

5. /**

6. * Created with IntelliJ IDEA.

7. * User: noah

8. * Date: 3/8/13

9. * 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

1. package org.noahx.javavsjson;

2.  

3. import java.io.*;

4. import java.util.Map;

5.  

6. /**

7. * Created with IntelliJ IDEA.

8. * User: noah

9. * 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

1. package org.noahx.javavsjson;

2.  

3. import org.apache.commons.lang3.SerializationUtils;

4.  

5. import java.io.Serializable;

6. import java.util.Map;

7.  

8. /**

9. * 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

1. package org.noahx.javavsjson;

2.  

3. import com.google.gson.Gson;

4.  

5. import java.io.UnsupportedEncodingException;

6. import java.util.Map;

7.  

8. /**

9. * 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

1. package org.noahx.javavsjson;

2.  

3. import net.minidev.json.JSONObject;

4. import net.minidev.json.JSONValue;

5. import net.minidev.json.parser.ParseException;

6.  

7. import java.io.UnsupportedEncodingException;

8. import java.util.Map;

9.  

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-smart不一樣，如果整數超過Integer的範圍轉Long，沒有超過轉Integer。浮點Float轉為Double型別。