為什么遠(yuǎn)程傳輸對象要序列化？
01、背景介紹
序列化和反序列化幾乎是工程師們每天都需要面對的事情，尤其是當(dāng)前流行的微服務(wù)開發(fā)。
光看定義上，對于初學(xué)者來說，可能很難一下子理解序列化的意義，尤其是面對這種特別學(xué)術(shù)詞語的時(shí)候，內(nèi)心會(huì)不由自主的發(fā)問：它到底是啥，用來干嘛的？
如果用通俗的方式來理解，你可以用變魔術(shù)的方式來理解它，就好比你想把一件鐵器從一個(gè)地方運(yùn)往到另一個(gè)地方，在出發(fā)的時(shí)候，通過魔術(shù)方式將這個(gè)東西融化成一桶鐵水，當(dāng)?shù)竭_(dá)目的地之后，又通過變魔術(shù)的方式，將這桶鐵水還原成一件鐵器。當(dāng)鐵器變成鐵水的過程，可以理解為序列化；從鐵水變成鐵器，可以理解為反序列化。
站在程序世界的角度看，我們都知道計(jì)算機(jī)之間傳遞信息的最小單元是字節(jié)流，序列化其實(shí)就是將一個(gè)對象變成所有的計(jì)算機(jī)都能識(shí)別的字節(jié)流；反序列化就是將接受到的字節(jié)流還原成一個(gè)程序能識(shí)別的對象。
簡單的說，序列化最終的目的是為了對象可以更方面的進(jìn)行跨平臺(tái)存儲(chǔ)和進(jìn)行網(wǎng)絡(luò)傳輸。
基本上只要是涉及到跨平臺(tái)存儲(chǔ)或者進(jìn)行網(wǎng)絡(luò)傳輸?shù)臄?shù)據(jù)，都需要進(jìn)行序列化。
互聯(lián)網(wǎng)早期的序列化方式主要有COM和CORBA。
COM主要用于Windows平臺(tái)，并沒有真正實(shí)現(xiàn)跨平臺(tái)，另外COM的序列化的原理利用了編譯器中虛表，使得其學(xué)習(xí)成本巨大（想一下這個(gè)場景， 工程師需要是簡單的序列化協(xié)議，但卻要先掌握語言編譯器）。由于序列化的數(shù)據(jù)與編譯器緊耦合，擴(kuò)展屬性非常麻煩。
CORBA是早期比較好的實(shí)現(xiàn)了跨平臺(tái)，跨語言的序列化協(xié)議。COBRA的主要問題是參與方過多帶來的版本過多，版本之間兼容性較差，以及使用復(fù)雜晦澀。這些政治經(jīng)濟(jì)，技術(shù)實(shí)現(xiàn)以及早期設(shè)計(jì)不成熟的問題，最終導(dǎo)致COBRA的漸漸消亡。J2SE 1.3之后的版本提供了基于CORBA協(xié)議的RMI-IIOP技術(shù)，這使得Java開發(fā)者可以采用純粹的Java語言進(jìn)行CORBA的開發(fā)。
隨著軟件技術(shù)的快速發(fā)展，之后逐漸出現(xiàn)了比較流行的序列化方式，例如：XML、JSON、Protobuf、Thrift 和 Avro等等。
這些序列化方式各有千秋，不能簡單的說哪一種序列化方式是最好的，只能從你的當(dāng)時(shí)環(huán)境下去選擇最適合你的序列化方式，如果你要為你的公司項(xiàng)目進(jìn)行序列化技術(shù)的選型，主要可以從以下幾個(gè)方面進(jìn)行考慮：
- 是否支持跨平臺(tái)：尤其是多種語言混合開發(fā)的項(xiàng)目，是否支持跨平臺(tái)直接決定了系統(tǒng)開發(fā)難度
- 序列化的速度：速度快的方式會(huì)為你的系統(tǒng)性能提升不少
- 序列化出來的大?。簲?shù)據(jù)越小越好，小的數(shù)據(jù)傳輸快，也不占帶寬，也能整體提升系統(tǒng)的性能
BB了這么多，作為一名 java 程序員，我們應(yīng)該如何使用序列化呢，以及序列化的過程中應(yīng)該需要注意的問題。
下面，我們一起來了解一下！
02、代碼實(shí)踐
java 實(shí)現(xiàn)序列化方式非常簡單，只需要實(shí)現(xiàn)Serializable接口即可，例如下面這個(gè)類。
public class Student implements Serializable {
/**
* 用戶名
*/
private String name;
/**
* 年齡
*/
private Integer age;
public Student(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}我們來測試一下，將Student對象進(jìn)行二進(jìn)制的數(shù)據(jù)存儲(chǔ)后，并從文件中讀取數(shù)據(jù)出來轉(zhuǎn)成Student對象，這個(gè)過程其實(shí)就是一個(gè)序列化和反序列化的過程。
public class ObjectMainTest {
public static void main(String[] args) throws Exception {
//序列化
serializeAnimal();
//反序列化
deserializeAnimal();
}
private static void serializeAnimal() throws Exception {
Student black = new Student("張三", 20);
System.out.println(black.toString());
System.out.println("=================開始序列化================");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.log"));
oos.writeObject(black);
oos.flush();
oos.close();
}
private static void deserializeAnimal() throws Exception {
System.out.println("=================開始反序列化================");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.log"));
Student black = (Student) ois.readObject();
ois.close();
System.out.println(black.toString());
}
}輸出結(jié)果：
Student{name='張三', age=20}
=================開始序列化================
=================開始反序列化================
Student{name='張三', age=20}看起來是不是超級簡單，但是請你別大意，這里面的坑還真不少，請看下面的問題匯總！
03、序列化問題匯總
3.1、static 屬性不能被序列化
實(shí)際在序列化的時(shí)候，被static修飾的屬性字段是不能被序列化進(jìn)去的，因?yàn)殪o態(tài)變量屬于類的狀態(tài)，序列化并不保存靜態(tài)變量！
3.2、Transient 屬性不會(huì)被序列化
被Transient修飾的屬性無法被序列化，眼見為實(shí)，我們給Student類的name字段加一個(gè)transient修飾符。
public class Student implements Serializable {
/**
* 用戶名
*/
private transient String name;
//...省略
}運(yùn)行測試方法，輸出結(jié)果如下：
Student{name='張三', age=20}
=================開始序列化================
=================開始反序列化================
Student{name='null', age=20}很明顯，被transient修飾的name屬性，反序列化后的結(jié)果為null。
3.3、序列化版本號 serialVersionUID 問題
只要是實(shí)現(xiàn)了Serializable接口的類都會(huì)有一個(gè)版本號，如果我們沒有定義，JDK 工具會(huì)按照我們對象的屬性生成一個(gè)對應(yīng)的版本號，當(dāng)然我們還可以自定義，例如給Student類自定義一個(gè)序列化版本號，操作如下。
public class Student implements Serializable {
//自定義序列化版本號
private static final long serialVersionUID = 1l;
//...省略
}如何驗(yàn)證這一點(diǎn)呢？
首先，我們先序列化一個(gè)Student對象，里面沒有自定義版本號，然后在反序列化的時(shí)候，我們給這個(gè)對象自定義一個(gè)版本號，運(yùn)行測試程序，看能不能反序列化成功？
Exception in thread "main" java.io.InvalidClassException: com.example.java.serializable.test1.entity.Student; local class incompatible: stream classdesc serialVersionUID = 821478144412499207, local class serialVersionUID = 1
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1885)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1751)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2042)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)答案很明顯，反序列化失??！
分析原因：Student對象序列化時(shí)的版本號是821478144412499207，反序列化時(shí)的版本號是1，兩者不一致，導(dǎo)致無法反序列化成功！
當(dāng)我們沒有顯式的自定義序列化版本號時(shí)，JDK 會(huì)根據(jù)當(dāng)前對象的屬性自動(dòng)生成一個(gè)對象的版本號，只要對象的屬性不會(huì)發(fā)生變化，這個(gè)版本號也基本上不會(huì)發(fā)生變化，但是當(dāng)對象的屬性發(fā)生了變化，對應(yīng)的反序列化對象沒有跟著一起變化，大概率會(huì)出現(xiàn)反序列化失??！
為了眼見為實(shí)，我們繼續(xù)以實(shí)際案例給大家演示一下。
還是以上面那個(gè)為主，我們先序列化一個(gè)Student對象，里面沒有自定義版本號，然后在反序列化操作的時(shí)候，我們給Student對象新增一個(gè)屬性email，同時(shí)也不自定義版本號。
public class Student implements Serializable {
/**
* 用戶名
*/
private String name;
/**
* 年齡
*/
private Integer age;
/**
* 郵箱
*/
private String email;
//省略set、get...
}看看運(yùn)行效果：
Exception in thread "main" java.io.InvalidClassException: com.example.java.serializable.test1.entity.Student; local class incompatible: stream classdesc serialVersionUID = 821478144412499207, local class serialVersionUID = -5996907635197467174
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1885)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1751)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2042)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)答案很顯然，反序列化報(bào)錯(cuò)了！兩者的版本號不一致！
在平時(shí)開發(fā)的過程中，實(shí)體類的屬性難免會(huì)發(fā)生改動(dòng)，我們有些同學(xué)啊，在寫代碼的時(shí)候只是把序列化的接口實(shí)現(xiàn)了，但是沒有自定義版本號，在這點(diǎn)上，我強(qiáng)烈建議大家一定要給每個(gè)實(shí)現(xiàn)了Serializable接口的類，自定義一個(gè)版本號，即使對象的屬性發(fā)生了變化，也不會(huì)影響到數(shù)據(jù)的序列化和反序列化操作！
操作很簡單，直接在實(shí)體類里面加上這個(gè)靜態(tài)變量即可！
//自定義序列化版本號
private static final long serialVersionUID = 1l;3.4、父類、子類序列化問題
在實(shí)際的開發(fā)過程中，尤其是實(shí)體類，為了對象屬性的復(fù)用，我們往往會(huì)采用繼承的方式來處理。
使用了繼承之后，父類屬性是否可以正常被序列化呢？下面我們一起來看看！
- 父類沒有實(shí)現(xiàn)序列化，子類實(shí)現(xiàn)序列化
首先我們創(chuàng)建兩個(gè)類Parent和Child，Child繼承自Parent。
public class Parent {
private String name;
public String getName() {
return name;
}
public Parent setName(String name) {
this.name = name;
return this;
}
}public class Child extends Parent implements Serializable{
private static final long serialVersionUID = 1l;
private String id;
public String getId() {
return id;
}
public Child setId(String id) {
this.id = id;
return this;
}
}編寫測試類，先序列化，然后再反序列化！
public class ObjectMainTest {
public static void main(String[] args) throws Exception {
serializeAnimal();
deserializeAnimal();
}
private static void serializeAnimal() throws Exception {
Child black = new Child();
black.setId("123");
black.setName("張三");
System.out.println("id:" + black.getId() + ",name:" + black.getName());
System.out.println("=================開始序列化================");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.log"));
oos.writeObject(black);
oos.flush();
oos.close();
}
private static void deserializeAnimal() throws Exception {
System.out.println("=================開始反序列化================");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.log"));
Child black = (Child) ois.readObject();
ois.close();
System.out.println("id:" + black.getId() + ",name:" + black.getName());
}
}運(yùn)行結(jié)果如下：
id:123,name:張三
=================開始序列化================
=================開始反序列化================
id:123,name:null結(jié)果很明顯，父類的屬性沒有被序列化進(jìn)去！
我們在來試試，另一種常見
- 父類實(shí)現(xiàn)序列化，子類不實(shí)現(xiàn)序列化
public class Parent implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
public String getName() {
return name;
}
public Parent setName(String name) {
this.name = name;
return this;
}
}public class Child extends Parent {
private String id;
public String getId() {
return id;
}
public Child setId(String id) {
this.id = id;
return this;
}
}接著運(yùn)行一次程序，結(jié)果如下！
id:123,name:張三
=================開始序列化================
=================開始反序列化================
id:123,name:張三結(jié)果很明顯，父類的屬性被序列化進(jìn)去！
假如，子類和父類，都實(shí)現(xiàn)了序列化，并且序列化版本號都不一樣，會(huì)不會(huì)出現(xiàn)問題呢？
- 父類實(shí)現(xiàn)序列化，子類實(shí)現(xiàn)序列化
public class Parent implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
public String getName() {
return name;
}
public Parent setName(String name) {
this.name = name;
return this;
}
}public class Child extends Parent implements Serializable{
private static final long serialVersionUID = 2l;
private String id;
public String getId() {
return id;
}
public Child setId(String id) {
this.id = id;
return this;
}
}運(yùn)行一次程序，結(jié)果如下！
id:123,name:張三
=================開始序列化================
=================開始反序列化================
id:123,name:張三父類的屬性序列化依然成功，當(dāng)父、子類都實(shí)現(xiàn)了序列化，并且定義了不同的版本號，這種情況下，版本號是跟著子類的版本號走的！
總結(jié)起來，當(dāng)父類實(shí)現(xiàn)序列化時(shí)，子類所有的屬性也會(huì)全部被序列化；但是當(dāng)父類沒有實(shí)現(xiàn)序列化，子類在序列化時(shí)，父類屬性并不會(huì)被序列化！
3.5、自定義序列化過程
Serializable接口內(nèi)部序列化是 JVM 自動(dòng)實(shí)現(xiàn)的，但是在某些少數(shù)的場景下，你可能想自定義序列化和反序列化的內(nèi)容，但是又不想改實(shí)體類屬性，這個(gè)時(shí)候你可以采用自定義序列化的實(shí)現(xiàn)方式。
自定義序列化方式，其實(shí)也很簡單，只需要實(shí)現(xiàn) JDK 自身提供的Externalizable接口就行，里面有兩個(gè)核心方法，一個(gè)是數(shù)據(jù)寫入，另一個(gè)是數(shù)據(jù)的讀取。
public interface Externalizable extends java.io.Serializable {
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}Externalizable接口的實(shí)現(xiàn)過程也很簡單，我們創(chuàng)建一個(gè)Person，實(shí)現(xiàn)自Externalizable的兩個(gè)方法。
public class Person implements Externalizable {
private static final long serialVersionUID = 1l;
private String name;
private int age;
/**
* 實(shí)現(xiàn)了Externalizable這個(gè)接口時(shí)需要提供無參構(gòu)造，在反序列化時(shí)會(huì)檢測
*/
public Person() {
System.out.println("Person: empty");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
System.out.println("person writeExternal...");
out.writeObject(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws ClassNotFoundException, IOException {
System.out.println("person readExternal...");
name = (String) in.readObject();
age = in.readInt();
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}測試Person對象的序列化和反序列化。
public class ExternalizableMain {
public static void main(String[] args) throws IOException, ClassNotFoundException {
serializable();
deserializable();
}
private static void serializable() throws IOException {
Person person = new Person("張三", 15);
System.out.println(person.toString());
System.out.println("=================開始序列化================");
FileOutputStream boas = new FileOutputStream("person.log");
ObjectOutputStream oos = new ObjectOutputStream(boas);
oos.writeObject(person);
oos.close();
boas.close();
}
private static void deserializable() throws IOException, ClassNotFoundException {
System.out.println("============反序列化=============");
ObjectInputStream bis = new ObjectInputStream(new FileInputStream("person.log"));
Person person = (Person)bis.readObject();
System.out.println(person.toString());
}
}運(yùn)行結(jié)果如下：
Person{name='張三', age=15}
=================開始序列化================
person writeExternal...
============反序列化=============
Person: empty
person readExternal...
Person{name='張三', age=15}04、小結(jié)
對象的序列化，在實(shí)際的開發(fā)過程中，使用的非常頻繁，尤其是微服務(wù)開發(fā)，如果你用的是SpringBoot + Dubbo組合的框架，那么在通過rpc調(diào)用的時(shí)候，如果傳輸?shù)膶ο鬀]有實(shí)現(xiàn)序列化，會(huì)直接報(bào)錯(cuò)！
在使用序列化的時(shí)候，坑點(diǎn)還不少，尤其是版本號的問題，這個(gè)很容易被忽略，大家在實(shí)際開發(fā)的時(shí)候，強(qiáng)烈推薦自定義版本號，這樣可以避免傳輸?shù)膶ο髮傩园l(fā)生變化的時(shí)候，接口反序列化出錯(cuò)的概率！
05、參考
1、https://www.huaweicloud.com/articles/6b6d1d97c0a9155899f0f7354c86610d.html
2、https://zhuanlan.zhihu.com/p/40462507
3、https://tech.meituan.com/2015/02/26/serialization-vs-deserialization.html
