文章目錄

• 一、簡介
• 二、序列化框架
• • 1、JDK
  • 2、XML序列化
  • 3、JSON序列化
  • 4、Hessian
  • 5、Avro序列化
  • 6、Kyro序列化
  • 7、Protostuff
• 三、序列化框架對比測試
• • 1、對象準(zhǔn)備
  • 2、JDK方式
  • 3、FastJson方式
  • 4、Hessian方式
  • 5、Protostuff方式
  • 6、測試代碼
• 四、總結(jié)
• 五、序列化應(yīng)用場景
• 六、注意事項(xiàng)

一、簡介

序列化：將Java對象轉(zhuǎn)化成字節(jié)數(shù)組。

反序列化：將字節(jié)數(shù)組轉(zhuǎn)化成Java對象。

影響序列化選擇有兩個(gè)因素：

• 序列化之后碼流的大小，如果太大，那么將會影響網(wǎng)絡(luò)傳輸?shù)男阅堋?/p>

• 序列化和反序列化過程的性能。

二、序列化框架

1、JDK

2、XML序列化

XML 協(xié)議，良好的可讀性，自由度極高的擴(kuò)展性，成了很長一段時(shí)間的序列化標(biāo)準(zhǔn)規(guī)范；

可以說XML序列化是開發(fā)中最常見也是發(fā)展時(shí)間最久的協(xié)議，并且支持跨進(jìn)程和跨語言交互。

但是缺陷也很明顯，即XML規(guī)范下的每一個(gè)屬性和值都是固定的標(biāo)簽形式，導(dǎo)致序列化后的字節(jié)流文件很大，而且解析復(fù)雜，效率很低。

方案：最常見的是 XStream 和 Java自帶的XML序列化和反序列化 兩種。

3、JSON序列化

XML序列化發(fā)展了多年后，也浮現(xiàn)了一些問題，比如開發(fā)并不簡便，解析XML復(fù)雜度較高，還有XML的標(biāo)準(zhǔn)規(guī)范比較多，自由度過高，導(dǎo)致很難有效的指定格式校驗(yàn)等，于是一種新的 輕量級的序列化交互的方案--JSON（JavaScript Object Notation） 出現(xiàn)了，相對于XML來說，json格式語法簡單，自由度較高，有很高的可讀性，并且在JSON序列化后的字節(jié)流小于XML序列化的結(jié)果，解析起來更方便，于是基于JSON的接口成了新的標(biāo)準(zhǔn)規(guī)范之一。

方案：最常見的Jackson、阿里巴巴開源的FastJson、谷歌的GSON。

4、Hessian

簡單說來，Hessian 是一個(gè)輕量級的RPC框架。

它基于HTTP協(xié)議傳輸，使用Hessian二進(jìn)制序列化，對于數(shù)據(jù)包比較大的情況比較友好。

5、Avro序列化

Avro 序列化設(shè)計(jì)初衷是為了支持大批量數(shù)據(jù)交換的應(yīng)用，支持二進(jìn)制序列化方式，并且自身提供了動(dòng)態(tài)語言支持，可以更加便捷、快速處理大批量的Avro數(shù)據(jù)

6、Kyro序列化

Kyro序列化 是主流的比較成熟的序列化方案之一，目前廣泛使用在大數(shù)據(jù)組件中，比如Hive、Storm等，性能比起Hessian還要優(yōu)越，但是缺陷較明顯，不支持跨語言交互，在dubbo2.6.x版本開始已經(jīng)加入了Kyro序列化的支持。

7、Protostuff

Protobuf 是谷歌提出的序列化方案，不同的是此方案 獨(dú)立于語言、平臺，谷歌提供了多個(gè)語言如java、c、go、python等語言的實(shí)現(xiàn)，也提供了多平臺的庫文件支持，使用比較廣泛，優(yōu)點(diǎn)在于 性能開銷很小，壓縮率很高，但是缺陷也很明顯，可讀性很差，并且protobuf需要使用特定語言的庫進(jìn)行翻譯轉(zhuǎn)換，使用起來較為麻煩。

三、序列化框架對比測試

下面我們挑選 JDK、FastJson、Hessian、Protostuff 四種序列化方式進(jìn)行對比測試。

測試之前我們需要準(zhǔn)備序列化對象，對象在序列化時(shí)，需要注意以下幾個(gè)關(guān)鍵字：

• Serializable：接口，是一個(gè)標(biāo)志性接口，標(biāo)識可以在 JVM 中進(jìn)行序列化，JVM 會為該類自動(dòng)生成一個(gè)序列化版本號。參與序列化與反序列化的類必須實(shí)現(xiàn) Serializable 接口。

• serialVersionUID：類屬性，序列化版本號，用于給 JVM 區(qū)別同名類，沒有提供版本號，JVM會默認(rèn)提供序列化版本號。

• transient：關(guān)鍵字，當(dāng)序列化時(shí)，不希望某些屬性參與，則可以使用這個(gè)關(guān)鍵字標(biāo)注該屬性。

1、對象準(zhǔn)備

SHeader.java

package com.springboottest.serialize.model;import java.io.Serializable; import java.util.Map;public class SHeader implements Serializable {private int code;private int length;private String type;private Map<String, Object> attach;public int getCode() {return code;}public void setCode(int code) {this.code = code;}public int getLength() {return length;}public void setLength(int length) {this.length = length;}public String getType() {return type;}public void setType(String type) {this.type = type;}public Map<String, Object> getAttach() {return attach;}public void setAttach(Map<String, Object> attach) {this.attach = attach;} }

SRequest.java

package com.springboottest.serialize.model;import java.io.Serializable; import java.util.HashMap; import java.util.Map;public class SRequest implements Serializable {private String version;private SHeader header;private Object body;public String getVersion() {return version;}public void setVersion(String version) {this.version = version;}public SHeader getHeader() {return header;}public void setHeader(SHeader header) {this.header = header;}public Object getBody() {return body;}public void setBody(Object body) {this.body = body;}public static class SRequestBuilder{public static SRequest build(){SRequest request = new SRequest();request.setVersion("1.0.0");SHeader header = new SHeader();header.setCode(200);header.setLength(202);header.setType("Object");Map<String, Object> attach = new HashMap<String, Object>();attach.put("name", "davis");attach.put("age", 30);header.setAttach(attach);request.setHeader(header);request.setBody("{\"code\":200, \"msg\":\"success\"}");return request;}} }

序列化接口 AbstractSerialize.java

package com.springboottest.serialize;public abstract class AbstractSerialize {public abstract <T> byte[] serialize(T obj);public abstract <T> T deserialize(byte[] data, Class<T> clazz); }

2、JDK方式

JDK自帶的序列化反序列化方式需要用到的兩個(gè)類：

• ObjectOutputStream：IO類，包含序列化對象的方法，writeObject()；

• ObjectInputStream：IO類，包含反序列化對象的方法，readObject()；

具體代碼 JDKSerialize.java

package com.springboottest.serialize;import com.springboottest.serialize.model.SRequest;import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream;public class JDKSerialize extends AbstractSerialize{@Overridepublic <T> byte[] serialize(T obj) {if (obj == null){throw new NullPointerException();}ByteArrayOutputStream bos = new ByteArrayOutputStream();try {ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(obj);return bos.toByteArray();} catch (Exception ex) {ex.printStackTrace();}return new byte[0];}@Overridepublic <T> T deserialize(byte[] data, Class<T> clazz) {ByteArrayInputStream bis = new ByteArrayInputStream(data);try {ObjectInputStream ois = new ObjectInputStream(bis);T obj = (T)ois.readObject();return obj;} catch (Exception ex) {ex.printStackTrace();}return null;} }

3、FastJson方式

FastJson 引入方式（pom.xml）：

<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.56</version> </dependency>

具體代碼 FastjsonSerialize.java

package com.springboottest.serialize; import com.alibaba.fastjson.JSON;public class FastjsonSerialize extends AbstractSerialize{@Overridepublic <T> byte[] serialize(T obj) {if (obj == null){throw new NullPointerException();}String json = JSON.toJSONString(obj);byte[] data = json.getBytes();return data;}@Overridepublic <T> T deserialize(byte[] data, Class<T> clazz) {T obj = JSON.parseObject(new String(data),clazz);return obj;} }

4、Hessian方式

Hessian 引入方式（pom.xml）：

<dependency><groupId>com.caucho</groupId><artifactId>hessian</artifactId><version>4.0.60</version> </dependency>

具體代碼 HessianSerialize.java

package com.springboottest.serialize;import com.caucho.hessian.io.HessianInput; import com.caucho.hessian.io.HessianOutput;import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream;public class HessianSerialize extends AbstractSerialize{@Overridepublic <T> byte[] serialize(T obj) {if (obj == null){throw new NullPointerException();}try{ByteArrayOutputStream bos = new ByteArrayOutputStream();HessianOutput ho = new HessianOutput(bos);ho.writeObject(obj);return bos.toByteArray();} catch(Exception ex){}return new byte[0];}@Overridepublic <T> T deserialize(byte[] data, Class<T> clazz) {if (data == null){throw new NullPointerException();}try{ByteArrayInputStream bis = new ByteArrayInputStream(data);HessianInput hi = new HessianInput(bis);return (T)hi.readObject();} catch(Exception ex){ex.printStackTrace();}return null;} }

5、Protostuff方式

Protostuff 引入方式（pom.xml）：

<dependency><groupId>io.protostuff</groupId><artifactId>protostuff-core</artifactId><version>1.6.0</version><scope>compile</scope> </dependency><dependency><groupId>io.protostuff</groupId><artifactId>protostuff-runtime</artifactId><version>1.6.0</version> </dependency>

具體代碼 ProtostuffSerialize.java

package com.springboottest.serialize;import io.protostuff.LinkedBuffer; import io.protostuff.ProtostuffIOUtil; import io.protostuff.Schema; import io.protostuff.runtime.RuntimeSchema; import java.util.Map; import java.util.concurrent.ConcurrentHashMap;public class ProtostuffSerialize extends AbstractSerialize{/*** 避免每次序列化都重新申請Buffer空間*/private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);/*** 緩存Schema*/private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<Class<?>, Schema<?>>();@Overridepublic <T> byte[] serialize(T obj) {if (obj == null){throw new NullPointerException();}Class<T> clazz = (Class<T>) obj.getClass();Schema<T> schema = getSchema(clazz);byte[] data;try {data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);} finally {buffer.clear();}return data;}@Overridepublic <T> T deserialize(byte[] data, Class<T> clazz) {Schema<T> schema = getSchema(clazz);T obj = schema.newMessage();ProtostuffIOUtil.mergeFrom(data, obj, schema);return obj;}private static <T> Schema<T> getSchema(Class<T> clazz) {Schema<T> schema = (Schema<T>) schemaCache.get(clazz);if (schema == null) {//這個(gè)schema通過RuntimeSchema進(jìn)行懶創(chuàng)建并緩存//所以可以一直調(diào)用RuntimeSchema.getSchema(),這個(gè)方法是線程安全的schema = RuntimeSchema.getSchema(clazz);if (schema != null) {schemaCache.put(clazz, schema);}}return schema;} }

6、測試代碼

SerializeTest.java

package com.springboottest.serialize;import com.springboottest.serialize.model.SRequest;public class SerializeTest {public static void main(String[] args) {System.out.println("------------ JDK Serialize ------------");test(new JDKSerialize());System.out.println();System.out.println("------------ FastJson Serialize ------------");test(new FastjsonSerialize());System.out.println();System.out.println("------------ Hessian Serialize ------------");test(new HessianSerialize());System.out.println();System.out.println("------------ Protostuff Serialize ------------");test(new ProtostuffSerialize());System.out.println();}public static void test(AbstractSerialize abstractSerialize){for(int i=0;i<5;i++){testSerialize(abstractSerialize);System.out.println("----------------------");}}public static void testSerialize(AbstractSerialize abstractSerialize){AbstractSerialize serialize = abstractSerialize;SRequest request = SRequest.SRequestBuilder.build();SRequest result = null;byte[] bytes = serialize.serialize(request);System.out.println("字節(jié)長度：" + bytes.length);int count = 100;long seriDuration = 0, deseriDuration = 0;long start = 0, end = 0;for(int i=0;i<count;i++){start = System.nanoTime();bytes = serialize.serialize(request);end = System.nanoTime();seriDuration += (end - start);start = System.nanoTime();result = serialize.deserialize(bytes, SRequest.class);end = System.nanoTime();deseriDuration += (end - start);}System.out.println("總次數(shù)：" + count);System.out.println("序列化總耗時(shí)：" + seriDuration/1000 + "us");System.out.println("反序列化總耗時(shí)：" + deseriDuration/1000 + "us");System.out.println("總耗時(shí)：" + (seriDuration + deseriDuration)/1000 + "us");} }

輸出結(jié)果（序列化和反序列化100次）：

------------ JDK Serialize ------------ 字節(jié)長度：526 總次數(shù)：100 序列化總耗時(shí)：10616us 反序列化總耗時(shí)：73580us 總耗時(shí)：84197us ---------------------- 字節(jié)長度：526 總次數(shù)：100 序列化總耗時(shí)：5269us 反序列化總耗時(shí)：18589us 總耗時(shí)：23859us ---------------------- 字節(jié)長度：526 總次數(shù)：100 序列化總耗時(shí)：3492us 反序列化總耗時(shí)：12892us 總耗時(shí)：16385us ---------------------- 字節(jié)長度：526 總次數(shù)：100 序列化總耗時(shí)：3483us 反序列化總耗時(shí)：9978us 總耗時(shí)：13462us ---------------------- 字節(jié)長度：526 總次數(shù)：100 序列化總耗時(shí)：2414us 反序列化總耗時(shí)：9121us 總耗時(shí)：11535us ---------------------------------- FastJson Serialize ------------ 字節(jié)長度：150 總次數(shù)：100 序列化總耗時(shí)：7581us 反序列化總耗時(shí)：42988us 總耗時(shí)：50570us ---------------------- 字節(jié)長度：150 總次數(shù)：100 序列化總耗時(shí)：8240us 反序列化總耗時(shí)：10351us 總耗時(shí)：18592us ---------------------- 字節(jié)長度：150 總次數(shù)：100 序列化總耗時(shí)：7231us 反序列化總耗時(shí)：9794us 總耗時(shí)：17026us ---------------------- 字節(jié)長度：150 總次數(shù)：100 序列化總耗時(shí)：5001us 反序列化總耗時(shí)：6936us 總耗時(shí)：11938us ---------------------- 字節(jié)長度：150 總次數(shù)：100 序列化總耗時(shí)：3552us 反序列化總耗時(shí)：5458us 總耗時(shí)：9011us ---------------------------------- Hessian Serialize ------------ 字節(jié)長度：243 總次數(shù)：100 序列化總耗時(shí)：14385us 反序列化總耗時(shí)：30783us 總耗時(shí)：45168us ---------------------- 字節(jié)長度：243 總次數(shù)：100 序列化總耗時(shí)：9114us 反序列化總耗時(shí)：13857us 總耗時(shí)：22972us ---------------------- 字節(jié)長度：243 總次數(shù)：100 序列化總耗時(shí)：7527us 反序列化總耗時(shí)：12365us 總耗時(shí)：19892us ---------------------- 字節(jié)長度：243 總次數(shù)：100 序列化總耗時(shí)：5211us 反序列化總耗時(shí)：9830us 總耗時(shí)：15042us ---------------------- 字節(jié)長度：243 總次數(shù)：100 序列化總耗時(shí)：6858us 反序列化總耗時(shí)：10122us 總耗時(shí)：16981us ---------------------------------- Protostuff Serialize ------------ 字節(jié)長度：86 總次數(shù)：100 序列化總耗時(shí)：2404us 反序列化總耗時(shí)：5213us 總耗時(shí)：7617us ---------------------- 字節(jié)長度：86 總次數(shù)：100 序列化總耗時(shí)：1450us 反序列化總耗時(shí)：1668us 總耗時(shí)：3119us ---------------------- 字節(jié)長度：86 總次數(shù)：100 序列化總耗時(shí)：1183us 反序列化總耗時(shí)：1440us 總耗時(shí)：2624us ---------------------- 字節(jié)長度：86 總次數(shù)：100 序列化總耗時(shí)：1038us 反序列化總耗時(shí)：1316us 總耗時(shí)：2355us ---------------------- 字節(jié)長度：86 總次數(shù)：100 序列化總耗時(shí)：991us 反序列化總耗時(shí)：1509us 總耗時(shí)：2501us ----------------------

四、總結(jié)

序列化方式字節(jié)流大小（B）100次耗時(shí)（us）1000次耗時(shí)（us）10000次耗時(shí)（us）

JDK	526	11 ~ 23	65 ~ 78	215 ~ 385
FastJson	150	9 ~ 18	11 ~ 46	20 ~ 40
Hessian	243	15 ~ 23	45 ~ 63	241 ~ 355
Protostuff	86	2 ~ 7	4 ~ 10	11 ~ 20

注：

• 字節(jié)流大小單位：B（字節(jié)）
• 序列化和反序列化總耗時(shí)單位：us（微秒）

從圖表中可以看出：

• JDK方式的碼流最大，不利于網(wǎng)絡(luò)傳輸；

• 從整體來看，Prorostuff的碼流最小，序列化性能最好。

五、序列化應(yīng)用場景

• 序列化會將內(nèi)存中對象的狀態(tài)轉(zhuǎn)換成二進(jìn)制文件保存到磁盤當(dāng)中，當(dāng)再次使用時(shí)會從磁盤中讀取該二進(jìn)制文件，將 Java 對象的狀態(tài)恢復(fù)到內(nèi)存中。

• 當(dāng)你想把內(nèi)存中的對象保存到磁盤文件或數(shù)據(jù)庫中時(shí)可以使用序列化。

• 當(dāng)你想在網(wǎng)絡(luò)傳輸中傳送 Java 對象時(shí)，可以使用序列化。

• 當(dāng)你想通過 RMI 傳輸對象時(shí)，可以使用序列化。

六、注意事項(xiàng)

• 序列化只會保存對象的屬性狀態(tài)，不會保存對象中的方法。

• 父類實(shí)現(xiàn)了 Serializable接口，則其子類也自動(dòng)實(shí)例化了該接口，也就是說子類不用顯式實(shí)現(xiàn) Serializable 接口也能參與序列化和反序列化。

• 一個(gè) 對象 A 的實(shí)例變量引用了其他 對象 B，在 A 對象實(shí)例化的過程中 ，也會序列化 B ，前提是 A、B 兩個(gè)類都實(shí)現(xiàn)了 Serializable 接口。

• 當(dāng)一個(gè)類實(shí)現(xiàn) Serializable 接口時(shí)，最好手動(dòng)指定一個(gè)序列化版本號（serialVersionUID），避免修改源代碼后導(dǎo)致反序列化出現(xiàn)異常。

• 當(dāng)一個(gè)類對象會被多次重復(fù)使用，且一般不會對其屬性做修改，就可以對其進(jìn)行序列化。例如數(shù)據(jù)庫操作中的實(shí)體類。

總結(jié)

以上是生活随笔為你收集整理的Java 序列化反序列化框架比较的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。