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

作者：肖國穎 2013-03-11 13:55:03

大家可能對Java序列化都有一個錯誤的認識，認為Java序列化比JSON的序列化效率高并且序列化的數(shù)據(jù)小，其實實際上并不一定是這樣，我這次就想通過實際測試來解開這個謎團。

一、背景

有項目需要傳輸Map結構的數(shù)據(jù)，有人傾向用Java序列化來做，有人傾向用JSON的序列化來做。所以我們還是比比吧。

Java觀點：Object2Object，使用時簡單快速。

JSON觀點：JSON格式與語言無關，擴展性強，速度也應該不慢。

二、測試方式

測試同一個Map<String,Object>并序列化為byte[]，并再將byte[]反序列化為 Map<String,Object>的過程。Object中包括 String，Integer，Long，Boolean，F(xiàn)loat，Double常規(guī)類型的數(shù)據(jù)。

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

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

測試各種大小不同的Map，并循環(huán)執(zhí)行同一操作N次，來得到一個相對穩(wě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）循環(huán)10萬次

序列化時間比較(y為序列化時間ms)

反序列化時間比較(y為反序列化時間ms)

序列化時間匯總比較(y為序列化與反序列化總時間ms)

序列化后byte大小比較(由于同類線重合顯示為2條線)

Map大小（100-1000）循環(huán)1萬次

序列化時間比較(y為序列化時間ms)

反序列化時間比較(y為反序列化時間ms)

序列化時間匯總比較(y為序列化與反序列化總時間ms)

序列化后byte大小比較(由于同類線重合顯示為2條線)

比較總結

Map在小于100時：

Java的反序列化時的性能要比Java序列化時性能差很多，1.5倍左右差距。

JSON序列化性能明顯由于Java序列化性能，尤其是反序列化過程。并且序列化后的數(shù)據(jù)大小也是JSON格式的小。

Map在大于100小于1000時：

Java的反序列化時的性能并沒有隨Map的大小變化而變差。

JSON陣營中Gson在序列化過程中，比Java只快了那么一點點。在反序列化過程中Gson開始領先與Java，但在Map的大小過700多以后，Gson的反序列化性能比Java要慢。但JSON陣營中的json-smart依然表現(xiàn)出色完全是兩個級別。

并不是Java的序列化速度總是最快體積最小，Java需要考慮對象類型，屬性類型與內部對象信息等一系列對數(shù)據(jù)本身并不相關的內容的處理。JSON以固定的格式，穩(wěn)定簡單的數(shù)據(jù)結構大大簡化了序列化過程，雖然也要創(chuàng)建新的Java數(shù)據(jù)對象但并不會比Java反序列化的速度慢。

從測試結果上看JSON的json-smart更適合項目的需要。

#p#

五、測試代碼源碼

SerializationTest接口

package org.noahx.javavsjson;  
 
import java.util.Map;  
 
/**  
 * Created with IntelliJ IDEA.  
 * User: noah  
 * Date: 3/8/13  
 * Time: 9:59 PM  
 * To change this template use File | Settings | File Templates.  
 */ 
public interface SerializationTest {  
 
    public String getTestName();  
 
    public Map<String, Object> testBytes2Map(byte[] bytes);  
 
    public byte[] testMap2Bytes(Map<String, Object> map);  
}

JavaSerializationTest

package org.noahx.javavsjson;  
 
import java.io.*;  
import java.util.Map;  
 
/**  
 * Created with IntelliJ IDEA.  
 * User: noah  
 * Date: 3/8/13  
 * Time: 10:05 PM  
 * To change this template use File | Settings | File Templates.  
 */ 
public class JavaSerializationTest implements SerializationTest {  
 
    @Override 
    public String getTestName() {  
        return "Java";  
    }  
 
    @Override 
    public Map<String, Object> testBytes2Map(byte[] bytes) {  
        Map<String, Object> result = null;  
        try {  
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);  
            ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);  
 
            result = (Map<String, Object>) inputStream.readObject();  
            inputStream.close();  
        } catch (ClassNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
 
        return result;  
    }  
 
    @Override 
    public byte[] testMap2Bytes(Map<String, Object> map) {  
        byte[] bytes = null;  
        try {  
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
            ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);  
 
            outputStream.writeObject(map);  
            outputStream.close();  
 
            bytes = byteArrayOutputStream.toByteArray();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return bytes;  
    }  
}

CommonLang3SerializationTest

package org.noahx.javavsjson;  
 
import org.apache.commons.lang3.SerializationUtils;  
import java.io.Serializable;  
import java.util.Map;  
 
/**  
 * Created with IntelliJ IDEA.  
 * User: noah  
 * Date: 3/9/13  
 * Time: 2:24 AM  
 * To change this template use File | Settings | File Templates.  
 */ 
public class CommonLang3SerializationTest implements SerializationTest {  
    @Override 
    public String getTestName() {  
        return "Commons Lang3";  
    }  
 
    @Override 
    public Map<String, Object> testBytes2Map(byte[] bytes) {  
        return (Map<String, Object>) SerializationUtils.deserialize(bytes);  
    }  
 
    @Override 
    public byte[] testMap2Bytes(Map<String, Object> map) {  
        return SerializationUtils.serialize((Serializable) map);  
    }  
}

GsonSerializationTest

package org.noahx.javavsjson;  
 
import com.google.gson.Gson;  
import java.io.UnsupportedEncodingException;  
import java.util.Map;  
 
/**  
 * Created with IntelliJ IDEA.  
 * User: noah  
 * Date: 3/8/13  
 * Time: 10:02 PM  
 * To change this template use File | Settings | File Templates.  
 */ 
public class GsonSerializationTest implements SerializationTest {  
 
    private Gson gson;  
 
    public GsonSerializationTest() {  
        gson = new Gson();  
    }  
 
    @Override 
    public String getTestName() {  
        return "Gson";  
    }  
 
    @Override 
    public Map<String, Object> testBytes2Map(byte[] bytes) {  
        Map<String, Object> result = null;  
        try {  
            result = gson.fromJson(new String(bytes, "UTF-8"), Map.class);  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  
 
    @Override 
    public byte[] testMap2Bytes(Map<String, Object> map) {  
        String str = gson.toJson(map);  
        byte[] bytes = null;  
        try {  
            bytes = str.getBytes("UTF-8");  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        }  
        return bytes;  
    }  
}

JsonSmartSerializationTest

package org.noahx.javavsjson;  
 
import net.minidev.json.JSONObject;  
import net.minidev.json.JSONValue;  
import net.minidev.json.parser.ParseException;  
import java.io.UnsupportedEncodingException;  
import java.util.Map;  
 
/**  
 * Created with IntelliJ IDEA.  
 * User: noah  
 * Date: 3/9/13  
 * Time: 1:30 AM  
 * To change this template use File | Settings | File Templates.  
 */ 
public class JsonSmartSerializationTest implements SerializationTest {  
    @Override 
    public String getTestName() {  
        return "Json Smart";  
    }  
 
    @Override 
    public Map<String, Object> testBytes2Map(byte[] bytes) {  
        Map<String, Object> map = null;  
        try {  
            map = (Map<String, Object>) JSONValue.parseStrict((new String(bytes, "UTF-8")));  
        } catch (ParseException e) {  
            e.printStackTrace();  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        }  
        return map;  
    }  
 
    @Override 
    public byte[] testMap2Bytes(Map<String, Object> map) {  
        String str = JSONObject.toJSONString(map);  
        byte[] result = null;  
        try {  
            result = str.getBytes("UTF-8");  
        } catch (UnsupportedEncodingException e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  
}

源碼下載：http://sdrv.ms/12ECmgG

P.S.

我也測試過Map<String,String>固定數(shù)據(jù)類型value只為String的情況，這時Java與JSON的性能的差距會減小，但JSON序列化性能與數(shù)據(jù)大小還是占優(yōu)勢，尤其是反序列化的速度JSON更出色。

Gson在數(shù)值反序列化后，因為Object無法確定類型，Map中的Long，Integer，F(xiàn)loat統(tǒng)一轉為了Double類型。

json-smart不一樣，如果整數(shù)超過Integer的范圍轉Long，沒有超過轉Integer。浮點Float轉為Double類型。

原文鏈接：http://my.oschina.net/noahxiao/blog/112759

責任編輯：張偉來源： oschina

Java JSON