什么是序列化與反序列化
序列化是指把對象轉(zhuǎn)換為字節(jié)序列的過程（Encoding an object as a byte stream is known as serializing the object.）
反序列化是指把字節(jié)序列恢復(fù)為對象的過程（The reverse process is known as deserializing it.）
序列化與反序列化面向的是成員變量，類的方法和靜態(tài)變量不參與序列化與反序列化。
什么場景下需要用到序列化與反序列化
當(dāng)兩個進(jìn)程進(jìn)行遠(yuǎn)程通信時，可以相互發(fā)送各種類型的數(shù)據(jù)，包括文本、圖片、音頻、視頻等， 而這些數(shù)據(jù)都會以二進(jìn)制序列的形式在網(wǎng)絡(luò)上傳送。那么當(dāng)兩個Java進(jìn)程進(jìn)行通信時，能否實現(xiàn)進(jìn)程間的對象傳送呢？答案是可以的。如何做到呢？這就需要Java序列化與反序列化了。換句話說，一方面，發(fā)送方需要把這個Java對象轉(zhuǎn)換為字節(jié)序列，然后在網(wǎng)絡(luò)上傳送；另一方面，接收方需要從字節(jié)序列中恢復(fù)出Java對象。
當(dāng)我們明晰了為什么需要Java序列化和反序列化后，我們很自然地會想Java序列化的好處。其好處一是實現(xiàn)了數(shù)據(jù)的持久化，通過序列化可以把數(shù)據(jù)永久地保存到硬盤上（通常存放在文件里），二是，利用序列化實現(xiàn)遠(yuǎn)程通信，即在網(wǎng)絡(luò)上傳送對象的字節(jié)序列。
即：涉及I/O(磁盤I/O 網(wǎng)絡(luò)I/O)，需要用到序列化與反序列化。
如何實現(xiàn)序列化與反序列化
以JDK實現(xiàn)方式為例，參考JDK中與I/O相關(guān)的類。
序列化
I/O OutputStream：
在序列化過程中，主要使用DataOutputStream(primitive Java data types) / ObjectOutputStream(primitive Java data types & objects) / OutputStream。
// serialize
public static <T> byte[] serialize(T obj) {
ObjectOutputStream objectOutputStream = null;
ByteArrayOutputStream byteArrayOutputStream = null;
try {
byteArrayOutputStream = new ByteArrayOutputStream();
objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(obj);
return byteArrayOutputStream.toByteArray();
} catch (Exception e) {
logger.error("serialize error", e);
}
return null;
}
反序列化
I/O InputStream：
在反序列化過程中，主要使用DataInputStream(read primitive Java data types) / ObjectInputStream(read primitive data and objects) / InputStream。
// deserialize
@SuppressWarnings("unchecked")
public static <T> T deserialize(byte[] bytes) {
try {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(byteArrayInputStream);
return (T) ois.readObject();
} catch (Exception e) {
logger.error("deserialize error", e);
}
return null;
}
transient
使用transient關(guān)鍵字修飾的實例變量不會參與默認(rèn)的序列化及反序列化，如實例的敏感信息字段等：
public class Person implements java.io.Serializable {
...
private transient String phone;
...
}
這里提到了默認(rèn)的序列化及反序列化，如果使用自定義序列化方式，則可以對transient關(guān)鍵字修飾的實例變量進(jìn)行序列化及反序列化，以實現(xiàn)Externalizable接口自定義序列化、反序列化為例：
public class ExternalizablePerson implements java.io.Externalizable {
private static final long serialVersionUID = 1866740372404660450L;
private String name;
private Integer age;
private String career;
private transient String phone;
/**
* 自定義序列化方式
* @param out
* @throws IOException
*/
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(name);
out.writeInt(age);
out.writeUTF(career);
out.writeUTF(phone);
}
/**
* 自定義反序列化方式
* @param in
* @throws IOException
* @throws ClassNotFoundException
*/
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
name = in.readUTF();
age = in.readInt();
career = in.readUTF();
phone = in.readUTF();
}
}
關(guān)于Externalizable接口，可以參考：What is the difference between Serializable and Externalizable in Java
serialVersionUID
serialVersionUID的取值是Java運(yùn)行時環(huán)境根據(jù)類的內(nèi)部細(xì)節(jié)自動生成的。如果對類的源代碼作了修改，再重新編譯，新生成的類文件的serialVersionUID的取值有可能會發(fā)生變化。
類的serialVersionUID的默認(rèn)值完全依賴于Java編譯器的實現(xiàn)，對于同一個類，用不同的Java編譯器編譯，有可能會導(dǎo)致不同的serialVersionUID。為了提高serialVersionUID的獨(dú)立性和確定性，強(qiáng)烈建議在一個可序列化類中顯示的定義serialVersionUID，為它賦予明確的值。
關(guān)于serialVersionUID，可以參考：What is a serialVersionUID and why should I use it?
writeReplace()/writeObject()/readObject()/readResolve()
這四個方法在 java.io.ObjectStreamClass 中定義，用于自定義序列化、反序列化。如果在Java實體類中聲明了這些方法，執(zhí)行順序如下（以反射的方式執(zhí)行，如writeObject在ObjectOutputStream中被調(diào)用，readObject在ObjectInputStream中被調(diào)用）：
| 執(zhí)行順序 | 方法名稱 | 類型 | 作用 | 方法描述 |
|---|---|---|---|---|
| 1 | writeReplace | 序列化 | 在writeObject之前執(zhí)行，可用于替換將要被序列化的實例（序列化代理） | private Object writeReplace() {} |
| 2 | writeObject | 序列化 | 對ObjectOutputStream中的byte執(zhí)行序列化操作 | private void writeObject(java.io.ObjectOutputStream out) throws IOException {} |
| 3 | readObject | 反序列化 | 對ObjectInputStream中的byte執(zhí)行反序列化操作 | private void readObject(java.io.ObjectInputStream out) throws IOException, ClassNotFoundException {} |
| 4 | readResolve | 反序列化 | 在readObject之后執(zhí)行，可用于替換返回的反序列化實例（單例） | private Object readResolve() {} |
序列化與反序列化中的注意事項
謹(jǐn)慎實現(xiàn)java.io.Serializable接口
實現(xiàn)java.io.Serializable接口后，會造成以下影響：
- 一旦類被發(fā)布，會大大降低修改該發(fā)布類的靈活性
如果一個類實現(xiàn)了Serializable接口，它的字節(jié)流編碼也變成了它導(dǎo)出API的一部分，它的子類都等價于實現(xiàn)了序列化，以后如果想要改變這個類的內(nèi)部表示法（添加／修改／刪除成員變量等），可能導(dǎo)致序列化形式不兼容。
- 增加了出現(xiàn)Bug和安全漏洞的可能性
一般對象是由構(gòu)造器創(chuàng)建的，而序列化也是一種對象創(chuàng)建機(jī)制，反序列化也可以構(gòu)造對象，默認(rèn)的反序列化機(jī)制構(gòu)造對象過程中，很容易遭到非法訪問，使構(gòu)造出來的對象，并不是原始對象，引發(fā)程序Bug和其他安全問題。
隨著類的新版本發(fā)布，帶來了更大的測試成本
性能開銷變大
序列化對象時，不僅會序列化當(dāng)前對象本身，還會對該對象引用的其他對象也進(jìn)行序列化，從而增大系統(tǒng)開銷
保護(hù)性編寫readObject方法
反序列化可以繞過構(gòu)造函數(shù)生成實例，如果實例在構(gòu)造過程中存在業(yè)務(wù)上或邏輯上的限制，在序列化上使用了默認(rèn)的序列化方式（即只繼承java.io.Serializable接口），則可以通過反序列化方式繞過構(gòu)造實例限制，從而生成不合法的實例。
以Peroid類為例，該類含有兩個字段：start(起始時間)，end(終止時間)，業(yè)務(wù)規(guī)則限制初始化Period實例時，start < end，構(gòu)造函數(shù)如下：
// all args constructor
public Period(Date start, Date end) {
this.start = new Date(start.getTime());
this.end = new Date(end.getTime());
// 檢查起止時間
if (this.start.compareTo(this.end) > 0) {
throw new IllegalArgumentException(start + " after " + end);
}
}
現(xiàn)在通過以下byte[]，反序列化生成Period實例：
private static final byte[] serializedBytes = new byte[] {
(byte)0xac, (byte)0xed, 0x00, 0x05, 0x73, 0x72, 0x00, 0x10, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x73, 0x69, 0x76,
0x65, 0x2e, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x39, (byte)0xc0, (byte)0x85, 0x2d, 0x4a, (byte)0xc1, 0x6b,
0x44, 0x02, 0x00, 0x02, 0x4c, 0x00, 0x03, 0x65, 0x6e, 0x64, 0x74, 0x00, 0x10, 0x4c, 0x6a, 0x61, 0x76, 0x61,
0x2f, 0x75, 0x74, 0x69, 0x6c, 0x2f, 0x44, 0x61, 0x74, 0x65, 0x3b, 0x4c, 0x00, 0x05, 0x73, 0x74, 0x61, 0x72,
0x74, 0x71, 0x00, 0x7e, 0x00, 0x01, 0x78, 0x70, 0x73, 0x72, 0x00, 0x0e, 0x6a, 0x61, 0x76, 0x61, 0x2e, 0x75,
0x74, 0x69, 0x6c, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x68, 0x6a, (byte)0x81, 0x01, 0x4b, 0x59, 0x74, 0x19, 0x03,
0x00, 0x00, 0x78, 0x70, 0x77, 0x08, 0x00, 0x00, 0x01, 0x63, 0x79, 0x21, 0x10, 0x00, 0x78, 0x73, 0x71, 0x00,
0x7e, 0x00, 0x03, 0x77, 0x08, 0x00, 0x00, 0x01, 0x63, (byte)0xb1, (byte)0xc7, 0x04, 0x00, 0x78
};
public static void main(String[] args) throws Exception {
// create instance via deserialize
Period illegalPeriod = SerializeUtil.deserialize(serializedBytes);
log.info("Period instance from deserialize: {}", illegalPeriod);
}
通過這種方式，我們構(gòu)造出了實例屬性start == 2018-05-31 00:00:00，end == 2018-05-20 00:00:00的非法實例。為了解決這一問題，需要通過編寫readObject方法，禁止通過反序列化創(chuàng)建非法實例：
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
// check start < end
if (start.compareTo(end) > 0) {
throw new InvalidObjectException(start + " after " + end);
}
}
使用序列化代理代替序列化實例
通過創(chuàng)建實例變量完全一致的靜態(tài)內(nèi)部類，作為序列化代理類，將序列化、反序列化過程交由序列化代理類完成：
/**
* 序列化代理類
*/
private static class PersonProxy implements Serializable {
private static final long serialVersionUID = -2902051239103230395L;
private String name;
private Integer age;
private String career;
private String phone;
public PersonProxy(Person p) {
log.info("PersonProxy(Person original)");
this.name = p.getName();
this.age = p.getAge();
this.career = p.getCareer();
this.phone = p.getPhone();
}
private Object readResolve() {
log.info("PersonProxy.readResolve()");
Person person = new Person(name, age, career, phone);
return person;
}
private void readObject(ObjectInputStream in) throws Exception {
log.info("PersonProxy.readObject");
in.defaultReadObject();
}
}
private Object writeReplace() {
log.info("Person.writeReplace()");
return new PersonProxy(this);
}
/**
* 本方法不會執(zhí)行，因為序列化已經(jīng)由PersonProxy實例代理
* @param out
*/
private void writeObject(ObjectOutputStream out) {
log.info("Person.writeObject()");
}
/**
* 防止攻擊者偽造數(shù)據(jù)(age < 0 || age >> 100)
* @param in
* @return
* @throws InvalidObjectException
*/
private void readObject(ObjectInputStream in) throws InvalidObjectException {
throw new InvalidObjectException("Proxy required");
}
通過使用序列化代理類，可以方便編寫保護(hù)性的readObject方法，避免因序列化、反序列化使用不當(dāng)造成潛在系統(tǒng)漏洞。
序列化與反序列化可能造成的系統(tǒng)漏洞
如“保護(hù)性編寫readObject方法”所示，通過構(gòu)造bytes可以在反序列化時生成不合法的實例，從而導(dǎo)致系統(tǒng)漏洞。
第三方序列化工具類介紹
Hessian
Hessian是一個輕量級的remoting on http工具，使用簡單的方法提供了RMI的功能。 相比WebService，Hessian更簡單、快捷。采用的是二進(jìn)制RPC協(xié)議，因為采用的是二進(jìn)制協(xié)議，所以它很適合于發(fā)送二進(jìn)制數(shù)據(jù)。
示例
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
...
Person person = new Person();
person.setName("Tom");
person.setAge(25);
person.setCareer("engineer");
person.setPhone("15201726287");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// serialize
HessianOutput hessianOutput = new HessianOutput(byteArrayOutputStream);
hessianOutput.writeObject(person);
byte[] bytes = byteArrayOutputStream.toByteArray();
log.info("serialized result: {}", bytes);
// deserialize
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
HessianInput hessianInput = new HessianInput(byteArrayInputStream);
Person deserializedPerson = (Person) hessianInput.readObject();
log.info("deserialized result: {}", deserializedPerson);
應(yīng)用
Hessian
Protobuf
Protobuf是一種輕便高效的結(jié)構(gòu)化數(shù)據(jù)存儲格式，用于結(jié)構(gòu)化數(shù)據(jù)序列化。它很適合做數(shù)據(jù)存儲或RPC數(shù)據(jù)交換格式，可用于通訊協(xié)議、數(shù)據(jù)存儲等領(lǐng)域。Protobuf是一種跨語言、跨平臺、可擴(kuò)展的序列化結(jié)構(gòu)數(shù)據(jù)格式。
示例
// Filename: person.proto
syntax="proto2";
option java_package = "protobuf.bean";
message Person {
required string name = 1;
required int32 age = 2;
required string phone = 3;
required string career = 4;
}
# generate Java class
protoc --java_out=[dir] [.proto file path]
PersonOuterClass.Person.Builder personBuilder = PersonOuterClass.Person.newBuilder();
personBuilder.setName("Jerry");
personBuilder.setAge(20);
personBuilder.setCareer("teacher");
personBuilder.setPhone("15112933840");
PersonOuterClass.Person person = personBuilder.build();
log.info("build result: {}", person);
// serialize
byte[] bytes = person.toByteArray();
log.info("serialized result: {}", bytes);
// deserialize
PersonOuterClass.Person deserializePerson = PersonOuterClass.Person.parseFrom(bytes);
log.info("deserialized result: {}", deserializePerson);
應(yīng)用
gRPC
Kryo
Kryo是一個快速高效的Java序列化框架，旨在提供快速、高效和易用的API。無論文件、數(shù)據(jù)庫或網(wǎng)絡(luò)數(shù)據(jù)Kryo都可以隨時完成序列化。Kryo還可以執(zhí)行自動深拷貝（克?。\拷貝（克?。＿@是對象到對象的直接拷貝，非對象->字節(jié)->對象的拷貝。
示例
序列化／反序列化：
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
...
Kryo kryo = new Kryo();
// declare Output stream
Output output = new Output(new FileOutputStream("file.bin"));
Person person = new Person();
person.setName("Tom");
person.setAge(25);
person.setCareer("engineer");
person.setPhone("15201726287");
// serialize
kryo.writeObject(output, person);
output.close();
// declare Input stream
Input input = new Input(new FileInputStream("file.bin"));
// deserialize
Person deserializePerson = kryo.readObject(input, Person.class);
log.info("deserialize result: {}", deserializePerson);
input.close();
深拷貝／淺拷貝：
Kryo kryo = new Kryo();
Engineer engineer = new Engineer();
engineer.setName("Tom");
engineer.setAge(25);
engineer.setCareer("engineer");
engineer.setPhone("15201726287");
// non primary type
List<String> skills = new ArrayList<>();
skills.add("math");
skills.add("programming");
skills.add("system");
skills.add("algorithm");
engineer.setSkills(skills);
// deep copy
Engineer deepCopyEngineer = kryo.copy(engineer);
log.info("deep copy result: {}, is skills equal: {}",
deepCopyEngineer, engineer.getSkills() == deepCopyEngineer.getSkills());
// shallow copy
Engineer shallowCopyEngineer = kryo.copyShallow(engineer);
log.info("shallow copy result: {}, is skills equal: {}",
shallowCopyEngineer, engineer.getSkills() == shallowCopyEngineer.getSkills());
應(yīng)用
Hive Spark Storm Akka
總結(jié)
關(guān)于序列化與反序列化的知識還有很多，如：
- java.util.HashMap、java.util.ArrayList 等集合類中關(guān)于序列化及反序列的自定義處理，為什么這么處理
- Kryo、Protobuf等第三方序列化工具做了哪些工作，使得序列化、反序列化速度相比JDK自帶的序列化、反序列速度優(yōu)秀很多
等，在后續(xù)系列博客中將繼續(xù)探索。
