序列化和反序列化
-
序列化就是指把物件轉換為位元組碼；
- 物件傳遞和儲存時，保證物件的完整性和可傳遞性。把物件轉換為有位元組碼，以便在網路上傳輸或儲存在本地檔案中；
-
反序列化就是指把位元組碼恢復為物件；
- 根據位元組流中儲存的物件狀態及描述資訊，通過反序列化重建物件；
-
一般情況下要求實現Serializable介面，該介面中沒有定義任何成員，只是起到標記物件是否可以被序列化的作用。
- 物件在進行序列化和反序列化的時候，必須實現Serializable介面，但並不強制宣告唯一的serialVersionUID，是否宣告serialVersionUID對於物件序列化的向上向下的相容性有很大的影響。
為何需要有序列化呢？
- 一方面是為了儲存在磁碟中，
- 另一方面為了網路遠端傳輸的內容。
Java實現序列化的方式
二進位制格式 + 指定語言層級
JavaBuiltIn（java原生）、JavaManual（根據成員變數型別，手工寫）、FstSerliazation、Kryo
二進位制格式 + 跨語言層級
Protobuf(Google)、Thrift(Facebook)、 AvroGeneric、Hessian
JSON 格式化
Jackson、Gson、FastJSON等
類JSON格式化：
CKS （textual JSON-like format）、BSON（JSON-like format with extended datatypes）、JacksonBson、MongoDB
XML檔案格式化
XmlXStream等
序列化的分類
序列化工具大致就可以分為以上幾類，簡單概括就分為二進位制binary和文字格式（json、xml）兩大類。
在速度的對比上一般有如下規律：
- binary > textual
- language-specific > language-unspecific
而textual中，由json相比xml冗餘度更低因此速度上更勝一籌，而json又比bson這類textual serialization技術上更成熟，框架的選擇上更豐富和優秀。
下面重點介紹下Kryo、fast-serialiation、fastjson、protocol-buffer
Java原生序列化(青銅級別)
-
Java本身提供的序列化工具基本上能勝任大多數場景下的序列化任務，關於其序列化機制。
-
需要類實現了Serializable或Externalizable介面，否則會丟擲異常，然後使用ObjectOutputStream與ObjectInputStream將物件寫入寫出。
-
Java自帶的序列化工具在序列化過程中需要不僅需要將物件的完整的class name記錄下來，還需要把該類的定義也都記錄下，包括所有其他引用的類，這會是一筆很大的開銷，尤其是僅僅序列化單個物件的時候。
-
正因為java序列化機制會把所有meta-data記錄下來，因此當修改了類的所在的包名後，反序列化則會報錯。
//物件轉成位元組碼
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new
ObjectOutputStream(byteArrayOutputStream);
outputStream.writeObject(VoUtil.getUser());
byte []bytes = byteArrayOutputStream.toByteArray();
outputStream.close();
//位元組碼轉換成物件
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
Model result = （Model) inputStream.readObject();
inputStream.close();
Kryo序列化框架（星耀級別）
-
kryo根據上述Java原生序列化機制的一些問題，對了很多優化工作，而且提供了很多serializer，甚至封裝了Unsafe型別的序列化方式，更多關於Unsafe型別的序列化方式。
-
kryo，是一個快速序列化/反序列化工具，效率比java高出一個級別，序列化出來的結果，是其自定義的、獨有的一種格式，體積更小，一般只用來進行序列化和反序列化，而不用於在多個系統、甚至多種語言間進行資料交換（目前 kryo 也只有 java 實現），目前已經有多家大公司使用，相對比較穩定。
<dependency>
<groupId>com.esotericsoftware</groupId>
<artifactId>kryo</artifactId>
<version>4.0.0</version>
</dependency>
KryoUtils序列化和反序列化操作
Kryo有三組讀寫物件的方法
- 如果不知道物件的具體類，且物件可以為null：
kryo.writeClassAndObject(output, object);
Object object = kryo.readClassAndObject(input);
- 如果類已知且物件可以為null：
kryo.writeObjectOrNull(output, someObject);
SomeClass someObject = kryo.readObjectOrNull(input, SomeClass.class);
- 如果類已知且物件不能為null:
kryo.writeObject(output, someObject);
SomeClass someObject = kryo.readObject(input, SomeClass.class);
序列化和反序列化操作工具類KryoUtils
Kryo 和 KryoRegister
Kryo的執行速度是java Serializable 的20倍左右
Kryo的檔案大小是java Serializable的一半左右
Kryo有兩種模式:
一種是先註冊(regist)，再寫物件，即writeObject函式，實際上如果不先註冊，在寫物件時也會註冊，併為class分配一個id。
注意，跨程式，則必須兩端都按同樣的模式，否則會出錯，因為必須要明確類對應的唯一id。
另一種是寫類名及物件，即writeClassAndObject函式。
writeClassAndObject函式是先寫入一個約定的數字，再寫入類ID（第一次要先寫-1，再寫類ID + 類名），寫入引用關係，最後才寫真正的資料。
Kryo的操作模式
static Kryo kryo = new Kryo();
public static byte[] serialize(Object obj) {
byte[] buffer = new byte[2048];
Output output = new Output(buffer);
kryo.writeClassAndObject(output, obj);
byte[] bs = output.toBytes();
output.close();
return bs;
}
public static Object deserialize(byte[] src) {
Input input = new Input(src);
Object obj = kryo.readClassAndObject(input);
input.close();
return obj;
}
Kryo的Register操作模式
static Kryo kryo = null;
static{
kryo = new Kryo();
kryo.setReferences(false);
kryo.setRegistrationRequired(false);
kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
}
public static byte[] serialize(Object obj) {
kryo.register(obj.getClass());
byte[] buffer = new byte[2048];
Output output = new Output(buffer);
kryo.writeObject(output, obj);
byte[] bs = output.toBytes();
output.close();
return bs;
}
public static Object deserialize(byte[] src, Class<?> clazz) {
kryo.register(clazz);
Input input = new Input(src);
Object obj = kryo.readObject(input, clazz);
input.close();
return obj;
}
推薦：https://blog.csdn.net/fanjunjaden/article/details/72823866
借鑑網上的一個很不錯的工具類！
public class KryoUtils {
/**
* （池化Kryo例項）使用ThreadLocal
*/
private static final ThreadLocal<Kryo> kryos = new ThreadLocal<Kryo>() {
@Override
protected Kryo initialValue() {
Kryo kryo = new Kryo();
//支援物件迴圈引用（否則會棧溢位）
kryo.setReferences(true);
// 不強制要求註冊類（註冊行為無法保證多個 JVM 內同一個類的註冊編號相同；
// 而且業務系統中大量的 Class 也難以一一註冊）
kryo.setRegistrationRequired(false);
//Fix the NPE bug when deserializing Collections.
kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
return kryo;
}
};
/**
* （池化Kryo例項）使用KryoPool
*/
private static KryoFactory factory = new KryoFactory() {
public Kryo create () {
Kryo kryo = new Kryo();
return kryo;
}
};
private static KryoPool pool = new KryoPool.Builder(factory).softReferences().build();
/**
* 使用ThreadLocal建立Kryo
* 把java物件序列化成byte[];
* @param obj java物件
* @return
*/
public static <T> byte[] serializeObject(T obj) {
ByteArrayOutputStream os=null;
Output output=null;
if(null != obj){
Kryo kryo = kryos.get();
try {
os = new ByteArrayOutputStream();
output = new Output(os);
kryo.writeObject(output, obj);
close(output);
return os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}finally {
close(os);
}
}
return null;
}
/**
* 使用ThreadLocal建立Kryo
* 把byte[]反序列化成指定的java物件
* @param bytes
* @param t 指定的java物件
* @param <T>
* @return 指定的java物件
*/
public static <T> T unSerializeObject(byte[] bytes,Class<T> t) {
ByteArrayInputStream is=null;
Input input=null;
if(null != bytes && bytes.length>0 && null!=t){
try {
Kryo kryo = kryos.get();
is = new ByteArrayInputStream(bytes);
input = new Input(is);
return kryo.readObject(input,t);
} catch (Exception e) {
e.printStackTrace();
}finally {
close(is);
close(input);
}
}
return null;
}
/**
* 使用ThreadLocal建立Kryo
* 把List序列化成byte[];
* @param list java物件
* @return
*/
public static <T> byte[] serializeList(List<T> list ) {
ByteArrayOutputStream os=null;
Output output=null;
byte[] bytes = null;
if(null != list && list.size()>0){
Kryo kryo = kryos.get();
try {
os = new ByteArrayOutputStream();
output = new Output(os);
kryo.writeObject(output,list);
close(output);
bytes = os.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace();
}finally {
close(os);
}
}
return null;
}
/**
* 使用ThreadLocal建立Kryo
* 把byte[]反序列化成指定的List<T>
* @param bytes byte陣列
* @param <T>
* @return 指定java物件的List
*/
public static <T> List<T> unSerializeList(byte[] bytes) {
ByteArrayInputStream is=null;
Input input=null;
if(null !=bytes && bytes.length>0){
try {
Kryo kryo = kryos.get();
is = new ByteArrayInputStream(bytes);
input = new Input(is);
List<T> list = kryo.readObject(input,ArrayList.class);
return list;
} catch (Exception e) {
e.printStackTrace();
}finally {
close(is);
close(input);
}
}
return null;
}
/**
* 使用ThreadLocal建立Kryo
* 把java物件轉序列化儲存在檔案中;
* @param obj java物件
* @return
*/
public static <T> boolean serializeFile(T obj,String path) {
if(null != obj){
Output output=null;
try {
Kryo kryo = kryos.get();
output = new Output(new FileOutputStream(path));
kryo.writeObject(output, obj);
return true;
} catch (Exception e) {
e.printStackTrace();
}finally {
close(output);
}
}
return false;
}
/**
* 使用ThreadLocal建立Kryo
* 把序列化的檔案反序列化成指定的java物件
* @param path 檔案路徑
* @param t 指定的java物件
* @param <T>
* @return 指定的java物件
*/
public static <T> T unSerializeFile(String path,Class<T> t) {
if(null != path && null !=t ){
Input input=null;
try {
Kryo kryo = kryos.get();
input = new Input(new FileInputStream(path));
return kryo.readObject(input,t);
} catch (Exception e) {
e.printStackTrace();
}finally {
close(input);
}
}
return null;
}
/**
* 使用KryoPool SoftReferences建立Kryo
* 把java物件序列化成byte[] ;
* @param obj java物件
* @return
*/
public static <T> byte[] serializePoolSoftReferences (T obj) {
if(null!=obj){
Kryo kryo =pool.borrow();
ByteArrayOutputStream os=null;
Output output=null;
try {
os = new ByteArrayOutputStream();
output = new Output(os);
kryo.writeObject(output, obj);
close(output);
byte [] bytes = os.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace();
}finally {
pool.release(kryo);
close(os);
}
}
return null;
}
/**
* 使用KryoPool SoftReferences建立Kryo
* 把byte[]反序列化成指定的java物件
* @param bytes
* @return
*/
public static <T> T unSerializePoolSoftReferences(byte[] bytes,Class<T> t) {
if(null !=bytes && bytes.length>0 && null!=t){
Kryo kryo =pool.borrow();
ByteArrayInputStream is=null;
Output output=null;
try {
is = new ByteArrayInputStream(bytes);
Input input= new Input(is);
return kryo.readObject(input, t);
} catch (Exception e) {
e.printStackTrace();
}finally {
pool.release(kryo);
close(is);
close(output);
}
}
return null;
}
/**
* 使用KryoPool SoftReferences建立Kryo
* 把java物件序列化成byte[] ;
* @param obj java物件
* @return
*/
public static <T> byte[] serializePoolCallback (final T obj) {
if(null != obj){
try {
return pool.run(new KryoCallback<byte[]>() {
public byte[] execute(Kryo kryo) {
ByteArrayOutputStream os = new ByteArrayOutputStream();
Output output = new Output(os);
kryo.writeObject(output,obj);
output.close();
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
return os.toByteArray();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
/**
* 使用KryoPool SoftReferences建立Kryo
* 把byte[]反序列化成指定的java物件
* @param bytes
* @return
*/
public static <T> T unSerializePoolCallback(final byte[] bytes, final Class<T> t) {
if(null != bytes && bytes.length>0 && null != t){
try {
return pool.run(new KryoCallback<T>() {
public T execute(Kryo kryo) {
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
Input input = new Input(is);
T result =kryo.readObject(input,t);
input.close();
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
/**
* 關閉io流物件
*
* @param closeable
*/
public static void close(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
FST序列化機制（鑽石級別）
-
FST（Fast-serialization-Tool），與kryo類似是apache組織的一個開源專案，完全相容JDK序列化協議的系列化框架，序列化速度大概是JDK的4-10倍，體積更小，大小是JDK大小1/3左右，重新實現的 Java 快速物件序列化的開發包。
-
相對來說是一個很新的序列化工具，速度於kryo有一些差距，在生產環境上的場景上測試，效果幾乎於kryo一致，都能瞬間反序列化出內容並渲染。
Java 快速序列化庫 FST 已經發布了 2.0 版本，該版本的包名已經更改，無法平滑升級。另外官方建議為了穩定性考慮還是使用最新的 1.58 版本為好
Maven配置
<dependency>
<groupId>de.ruedigermoeller</groupId>
<artifactId>fst</artifactId>
<version>1.58</version>
</dependency>
案例程式碼
static FSTConfiguration configuration = FSTConfiguration
.createDefaultConfiguration();
public static byte[] serialize(Object obj){
return configuration.asByteArray((Serializable)obj);
}
public static Object deserialize(byte[] sec){
return configuration.asObject(sec);
}
官方文件： https://github.com/RuedigerMoeller/fast-serialization/wiki/Serialization
protostuff（王者級別）
Protocol buffers是一個用來序列化結構化資料的技術，支援多種語言諸如C++、Java以及Python語言，可以使用該技術來持久化資料或者序列化成網路傳輸的資料。相比較一些其他的XML技術而言，該技術的一個明顯特點就是更加節省空間（以二進位制流儲存）、速度更快以及更加靈活。
protostuff，是google在原來的protobuffer是的優化產品。使用起來也比較簡單易用，目前效率也是最好的一種序列化工具。
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.4.0</version>
</dependency>
protostuff工具類
public class ProtostuffUtil {
public static <T> byte[] serializer(T t){
Schema schema = RuntimeSchema.getSchema(t.getClass());
return ProtostuffIOUtil.toByteArray(t,schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
}
public static <T> T deserializer(byte []bytes,Class<T> c) {
T t = null;
try {
t = c.newInstance();
Schema schema = RuntimeSchema.getSchema(t.getClass());
ProtostuffIOUtil.mergeFrom(bytes,t,schema);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return t;
}
}
Fastjson（鑽石）
一個JSON庫涉及的最基本功能就是序列化和反序列化。Fastjson支援java bean的直接序列化。 使用com.alibaba.fastjson.JSON這個類進行序列化和反序列化。
public static String serialize(Object obj){
String json = JSON.toJSONString(obj);
return json;
}
public static Object deserialize(String json, Class<?> clazz){
Object obj = JSON.parseObject(json, clazz);
return obj;
}
Maven配置
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
Gson（鑽石）
這裡採用JSON格式同時使用採用Google的gson進行轉義.
static Gson gson = new Gson();
public static String serialize(Object obj){
String json = gson.toJson(obj);
return json;
}
public static Object deserialize(String json, Class<?> clazz){
Object obj = gson.fromJson(json, clazz);
return obj;
}
Jackson（鉑金）
Jackson庫（http://jackson.codehaus.org），是基於java語言的開源json格式解析工具，整個庫（使用最新的2.2版本）包含3個jar包：
- jackson-core.jar——核心包（必須），提供基於“流模式”解析的API。
- jackson-databind——資料繫結包（可選），提供基於“物件繫結”和“樹模型”相關API。
- jackson-annotations——註解包（可選），提供註解功能。
效能較高，“流模式”的解析效率超過絕大多數類似的json包。
核心包：JsonParser（json流讀取），JsonGenerator（json流輸出）。
資料繫結包：ObjectMapper（構建樹模式和物件繫結模式），JsonNode（樹節點）
public static String serialize(Object obj){
ObjectMapper mapper = new ObjectMapper();
String json = null;
try {
json = mapper.writeValueAsString(obj);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return json;
}
public static Object deserialize(String json, Class<?> clazz){
ObjectMapper mapper = new ObjectMapper();
Object obj = null;
try {
obj = mapper.readValue(json, clazz);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return obj;
}
下表是幾種方案的各項指標的一個對比
