Android中的序列化和反序列化

概念

正式的：
序列化：把對象轉換爲字節序列的過程稱爲對象的序列化。
反序列化：把字節序列恢復爲對象的過程稱爲對象的反序列化。
通俗舉慄
比如：現在我們都會在淘寶上買桌子，桌子這種很不規則不東西，該怎麼從一個城市運輸到另一個城市，這時候一般都會把它拆掉成板子，再裝到箱子裏面，就可以快遞寄出去了，這個過程就類似我們的序列化的過程（把數據轉化爲可以存儲或者傳輸的形式）。當買家收到貨後，就需要自己把這些板子組裝成桌子的樣子，這個過程就像反序列的過程（轉化成當初的數據對象）。

爲什麼要序列化？

我們都知道，在進行瀏覽器訪問的時候，我們看到的文本、圖片、音頻、視頻等都是通過二進制序列進行傳輸的，那麼如果我們需要將Java對象進行傳輸的時候，是不是也應該先將對象進行序列化？答案是肯定的，我們需要先將Java對象進行序列化，然後通過網絡，IO進行傳輸，當到達目的地之後，再進行反序列化獲取到我們想要的對象，最後完成通信。

序列化的兩種方式

Java中提供了Serializable空接口來爲對象提供標準的序列化和反序列化操作，使用Serializable來實現序列化很簡單，定義目標類實現Serializable接口，並通過private static final long serialVersionUID = 1L;指定一個serialVersionUID 值即可；Android中提供了新的序列化方式，實現Parcelable接口，過程要複雜一些

方式一：Serializable

（1）實現Serializable空接口的實體類

public class CarBean implements Serializable{

    private static final long serialVersionUID = 1L;
    
    private static String objType = "car";
    private String name;
    private int price;
    private transient String type;
    
    public CarBean(String name,int price,String type){
        this.name = name;
        this.price = price;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "CarBean [name=" + name + ", price=" + price + ", type=" + type +",objType="+objType+ "]";
    }
    
    
}

（2）進行序列化和反序列化

public class SerializableTest {

    public static void main(String[] args) throws Exception {
        serializeCarBean();
        CarBean car = deserializeCarBean();
        System.out.println(car.toString());
    }
    
     /**
     * 序列化
     */
    private static void serializeCarBean() throws IOException {
        CarBean car = new CarBean("蘭博基尼",80000000,"超跑");
        // ObjectOutputStream 對象輸出流，將 CarBean 對象存儲到E盤的 CarBean.txt 文件中，完成對 CarBean 對象的序列化操作
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/CarBean.txt")));
        oos.writeObject(car);
        System.out.println("CarBean 對象序列化成功！");
        oos.close();
    }
 
    /**
     * 反序列化
     */
    private static CarBean deserializeCarBean() throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/CarBean.txt")));
        CarBean car = (CarBean) ois.readObject();
        System.out.println("CarBean 對象反序列化成功！");
        return car;
    }

}

對上面的2個操作文件流的類的簡單說明
ObjectOutputStream代表對象輸出流：
它的writeObject(Object obj)方法可對參數指定的obj對象進行序列化，把得到的字節序列寫到一個目標輸出流中。
ObjectInputStream代表對象輸入流：
它的readObject()方法從一個源輸入流中讀取字節序列，再把它們反序列化爲一個對象，並將其返回。

【1】跑上述完整代碼，得到的運行結果如下：

CarBean 對象序列化成功！
CarBean 對象反序列化成功！
CarBean [name=蘭博基尼, price=80000000, type=null,objType=car]

1、對象成功序列化和反序列化
2、可以看到transient修飾的變量不會被序列化
3、既然對象序列化，那麼不屬於對象的static變量是否是被序列化了呢？我們後面驗證一下。

【2】修改部分代碼，修改部分如下：

public static void main(String[] args) throws Exception {
        serializeCarBean();
//      CarBean car = deserializeCarBean();
//        System.out.println(car.toString());
    }

先執行序列化，執行完畢，修改CarBean 中的static值objType=car1（執行序列化時是objType=car）

public static void main(String[] args) throws Exception {
//      serializeCarBean();
        CarBean car = deserializeCarBean();
        System.out.println(car.toString());
    }

修改完成之後，註釋序列化代碼，直接反序列化，執行結果如下：

CarBean 對象反序列化成功！
CarBean [name=蘭博基尼, price=80000000, type=null,objType=car1]

可以看到static修飾的變量果然沒有被序列化，而是採用了最新的值。

【3】有的時候實現Serializable也沒有去指定serialVersionUID 值，也沒啥問題，我們來驗證一下它的作用：

修改代碼，註釋掉serialVersionUID 值，並且註釋掉反序列化部分的代碼，先單獨進行序列化操作，如下：

//  private static final long serialVersionUID = 1L;

public static void main(String[] args) throws Exception {
        serializeCarBean();
//      CarBean car = deserializeCarBean();
//        System.out.println(car.toString());
    }

序列化執行成功，然後隨便去掉或者添加一個屬性，打開反序列化代碼，這裏我們添加一個屬性desc，如下：

public class CarBean implements Serializable{

//  private static final long serialVersionUID = 1L;
    
    private static String objType = "car";
    private String name;
    private int price;
    private String desc;
    private transient String type;
        ......省略未改變代碼......
}

反序列化代碼

public static void main(String[] args) throws Exception {
//      serializeCarBean();
        CarBean car = deserializeCarBean();
        System.out.println(car.toString());
    }

執行代碼，運行結果

Exception in thread "main" java.io.InvalidClassException: serial.CarBean; local class incompatible: stream classdesc serialVersionUID = 4932330409554208456, local class serialVersionUID = -6380806296602337257
    at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
    at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
    at java.io.ObjectInputStream.readClassDesc(Unknown Source)
    at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
    at java.io.ObjectInputStream.readObject0(Unknown Source)
    at java.io.ObjectInputStream.readObject(Unknown Source)
    at serial.SerializableTest.deserializeCarBean(SerializableTest.java:35)
    at serial.SerializableTest.main(SerializableTest.java:14)

上面代碼目標實體類中是沒有明確的給這個 serialVersionUID 賦值，但是，Java會自動的根據實體的屬性計算出一個哈希值賦給serialVersionUID ，在我們執行序列化的時候，那時候還沒有這個desc屬性，所以，自動生成的serialVersionUID 這個值，和在反序列化的時候自動生成的serialVersionUID值是不同的，就拋異常啦。如果我們手動指定，根據我們手動指定的值無論是對象發生了什麼變化，這個值是相同的，我們就可以成功反序列化該對象，能夠最大限度的恢復數據，避免程序崩潰。

Serializable方式總結：

（1）serialVersionUID值不手動指定不會影響序列化，如果有反序列化操作，目標對象屬性發生變化會無法成功反序列化，最好還是手動指定。
（2）transient（短暫的; 轉瞬即逝的; 臨時的）修飾的屬性，是不會被序列化的。這個修飾符是專門用來保證被修飾的屬性不被序列化的，在java中還沒發現其他的作用。
（3）static修飾的屬性，不屬於對象，同樣不會被序列化。

方式二：Parcelable

實現方式比較標準，代碼如下：

public class ConditionBean implements Parcelable{

    public String id;
    public String name;
    public String isSelect = "1";//1未選 2選擇;默認未選擇

    public ConditionBean(){}

    public ConditionBean(String code,String msg){
        this.id = code;
        this.name = msg;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    // 注意這裏的write順序跟下面的read順序一定要一樣
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(id);
        dest.writeString(name);
        dest.writeString(isSelect);
    }

    public static final Parcelable.Creator<ConditionBean> CREATOR = new Creator<ConditionBean>() {

        @Override
        public ConditionBean createFromParcel(Parcel source) {
            ConditionBean bean = new ConditionBean();
            bean.id = source.readString();
            bean.name = source.readString();
            bean.isSelect = source.readString();
            return bean;
        }

        @Override
        public ConditionBean[] newArray(int size) {
            return new ConditionBean[size];
        }
    };
}

（1）writeToParcel(Parcel dest, int flags)完成對象的序列化操作。
（2）CREATOR 完成對象的反序列化操作。從createFromParcel(Parcel source)中我們可以看到反序列化是創建了一個複本來保存了對象的各個值。
（3）describeContents()此方法一般返回0即可。
需要注意的：write順序跟read順序一定要一樣。

附上一張藝術開發探索的圖：

image.png

兩種方式的區別

Parcelable和Serializable都是實現序列化並且都可以用於Intent間傳遞數據。Serializable是Java的實現方式，會頻繁的IO操作，所以消耗比較大，但是實現方式簡單； Parcelable是Android提供的方式，效率比較高，但是實現起來複雜一些；二者的選取規則是：內存序列化上選擇Parcelable，存儲到設備或者網絡傳輸上選擇Serializable(當然Parcelable也可以但是稍顯複雜)

參考文章：
包含了自定義類對象作爲成員參數的情況
Android中Parcelable的原理和使用方法

作者：On丶
鏈接：https://www.jianshu.com/p/38e7cd44cd0d
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯繫作者獲得授權並註明出處。

Android中的序列化和反序列化

概念

爲什麼要序列化？

序列化的兩種方式

兩種方式的區別

2024年DataOps趨勢預測：AI不會取代數據工程師

雲原生週刊：K8s 中的服務和網絡｜ 2024.4.29

[轉帖]cpupower

今天，昨天，近七天，近30天，近90天，js封裝

華爲云云原生FinOps解決方案，釋放雲原生最大價值

管理程序員的第三年，給大家的一些建議

One take，可望而不可即

Android Studio恢復誤操作

Android 取得系統開機的時間

如何清除“映射網絡驅動器”的歷史記錄

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結