Android中的序列化和反序列化

概念

  • 正式的：
    序列化：把對象轉換為字節(jié)序列的過程稱為對象的序列化。
    反序列化：把字節(jié)序列恢復為對象的過程稱為對象的反序列化。
  • 通俗舉栗
    比如：現(xiàn)在我們都會在淘寶上買桌子，桌子這種很不規(guī)則不東西，該怎么從一個城市運輸?shù)搅硪粋€城市，這時候一般都會把它拆掉成板子，再裝到箱子里面，就可以快遞寄出去了，這個過程就類似我們的序列化的過程（把數(shù)據(jù)轉化為可以存儲或者傳輸?shù)男问剑?。當買家收到貨后，就需要自己把這些板子組裝成桌子的樣子，這個過程就像反序列 的過程（轉化成當初的數(shù)據(jù)對象）。

為什么要序列化？

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

序列化的兩種方式

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

  • 方式一：Serializable

（1）實現(xiàn)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)方法可對參數(shù)指定的obj對象進行序列化，把得到的字節(jié)序列寫到一個目標輸出流中。
ObjectInputStream代表對象輸入流：
它的readObject()方法從一個源輸入流中讀取字節(jié)序列，再把它們反序列化為一個對象，并將其返回。

  • 【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());
    }

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

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

修改完成之后，注釋序列化代碼，直接反序列化，執(zhí)行結果如下：

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

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

  • 【3】有的時候實現(xiàn)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());
    }

序列化執(zhí)行成功，然后隨便去掉或者添加一個屬性，打開反序列化代碼，這里我們添加一個屬性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());
    }

執(zhí)行代碼，運行結果

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會自動的根據(jù)實體的屬性計算出一個哈希值賦給serialVersionUID ，在我們執(zhí)行序列化的時候，那時候還沒有這個desc屬性，所以，自動生成的serialVersionUID 這個值，和在反序列化的時候自動生成的serialVersionUID值是不同的，就拋異常啦。如果我們手動指定，根據(jù)我們手動指定的值無論是對象發(fā)生了什么變化，這個值是相同的，我們就可以成功反序列化該對象，能夠最大限度的恢復數(shù)據(jù)，避免程序崩潰。

Serializable方式總結：

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

  • 方式二：Parcelable

實現(xiàn)方式比較標準，代碼如下：

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)中我們可以看到反序列化是創(chuàng)建了一個復本來保存了對象的各個值。
（3）describeContents()此方法一般返回0即可。
需要注意的：write順序跟read順序一定要一樣。

附上一張藝術開發(fā)探索的圖：


image.png

兩種方式的區(qū)別

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

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

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容