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
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。