Android IPC系列--序列化机制

简介

什么是序列化？序列化就是将一个对象转换为可以在流中传输并保存在文件中实现对象持久化的一个过程。既然有存储过程，那当然得有读取了，不然光存起来取不出来也就没什么意义了，那这个取的过程就是“反序列化”了。我们Android中实现序列化一般有两种方法：实现Serializable或者Parcelable接口，前者是Java自带的实现方式，而后者是Android独有的，这两个方法都能实现序列化，而Parcelable方式的实现原理是将一个完整的对象拆分为Intent能传输的数据类型的细小部分，从而实现对象的传输和存储。

Serializable详解

1、Serializable的使用
Serializable的使用很简单，只需新建一个类实现Serializable接口即可，下面上代码,,先来最简单的方式：

public class Person implements Serializable{
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    private int id;
    private String name;
    private String sex;

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

对象的存储过程只需创建一个对象，设置好属性，然后通过ObjectOutputStream来写入文件即可：

  Person p=new Person();
  p.setId(1);
  p.setName("小王");
  p.setSex("男");
  try {
  ObjectOutputStream oos=new ObjectOutputStream(new 
  FileOutputStream(Environment.getExternalStorageDirectory()+"/person.txt"));
  oos.writeObject(p);
  oos.close();
  } catch (IOException e) {
      e.printStackTrace();
  }

然后反序列化就是通过ObjectInputStream来读出文件内容，并强转为序列化前的类型。

  try {
    ObjectInputStream ois=new ObjectInputStream(
    new   FileInputStream(Environment.getExternalStorageDirectory()+"/person.txt"));
    Person rp= (Person) ois.readObject();
    tv.setText(rp.toString());
    ois.close();
  } catch (IOException e) {
    e.printStackTrace();
  } catch (ClassNotFoundException e) {
    e.printStackTrace();
  }

简单的序列化使用过程就完成了。不过这样做是不安全的，试想一下，你实现序列化的目的是为了将对象持久化存储，不管是存到文件中还是数据库中，都是为了日后用到的时候能再取出来，但是版本迭代是无可避免的，当你今天存储了一个对象到数据库里，几天后版本更新，对应的类增添或者删除了某个属性或者方法，这个时候你在反序列化这类对象，想重新使用，这个时候旧货发生错误，反序列失败并报错，你还一脸懵逼地在想是不是存储文件损坏了。其实我们是需要一个serialVersionUID来标识一个可序列化类的，这样在你修改了类的某些属性的时候，不至于反序列化失败。下面我们来模拟这个情景,我们仍然使用前面创建的类来测试，我们先原封不动的进行一次序列化过程，将对象保存在文件中，然后修改person类，增加一个属性

private String temp="I am a temp";

接着重新运行App，进行反序列化操作，这个时候肯定会报错，具体错误信息大致如下：

local class incompatible: stream classdesc serialVersionUID = 3133927331174281271, local class serialVersionUID = -8495657734254524720

错误提示serialVersionUID 不匹配，我们并没有设置serialVersionUID 啊？其实实现了Serializable接口，如果不指定serialVersionUID ，Java会自动根据当前类生成一个UID，这就是问题所在了，在序列化的时候，序列化机制是会将这个UID一并保存在某个地方，用来在反序列化的时候进行验证的，如果我们没有自己去指定这个UID，而是任由jvm去自己生成，那么当你改动了类之后，UID必然也跟着改变，这时反序列化就会验证不通过，导致反序列化失败。
那么这个UID怎么设置呢，其实也很简单，只需在类中定义一个属性：

private static final long serialVersionUID = -6095421372692637008L;

如果你使用的是Android studio ，是可以快速生成这个UID的，首先你需要打开File->Editor->Inspections->Serialization issues把里面的Serializable class without ‘serialVersionUID’勾上，然后在实现了Serializable接口的类上按Ctrl+Enter就可以看到生成选项了。当我们自己设置了serialVersionUID之后，就不会再出现因为修改了类结构导致的反序列化失败问题了。Serializable的使用就讲解完了。

Parcelable详解

既然Java本身就实现了Serializable来进行序列化，为什么谷歌还要造一个Parcelable呢，是否多此一举？答案肯定是否啦，至于为什么Android中会实现一个新的序列化机制，那么肯定是因为serializable接口在Android上会“水土不服”或者性能较低。在Android开发中，activity间传递数据想必每个Android开发者都不会陌生，传递基本数据类型没啥问题，要是想传递对象呢？此时如果使用serializable，是不是得先把对象给存到内存卡上，然后在目标界面进行读取呢？这想想都觉得可怕，读写内存卡是非常耗时的，这在实际项目中是绝对无法接受的，而Parceable接口就可以避免这个问题，那么接下来我们看看怎么使用这个Android独有的序列化方式吧。
同样需要新建一个类，然后继承Parceable接口，如果你使用的是Android studio进行开发，继承了接口后IDE便会提示你要重写一些必要的方法，我们直接看代码吧：

public class PersonByParceable  implements Parcelable{
    private String name;
    private int age;

    public boolean isMale() {
        return isMale;
    }

    public void setMale(boolean male) {
        isMale = male;
    }

    private boolean isMale;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    protected PersonByParceable(Parcel in) {
        //这里read属性需要按照write的时候的顺序来读取
        name=in.readString();
        age=in.readInt();
        isMale=Boolean.valueOf(in.readString());
    }

    public static final Creator<PersonByParceable> CREATOR = new Creator<PersonByParceable>() {
        @Override
        public PersonByParceable createFromParcel(Parcel in) {
            return new PersonByParceable(in);
        }

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

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
        dest.writeString(String.valueOf(isMale));
    }
}

需要注意的有几个地方，writeToParcel方法就是进行序列化的过程的方法，你需要使用Parcel参数保存你的类属性；然后带有Parcel 参数的构造方法就是反序列化用的，你可以在里面读取序列化的时候保存的类属性，不过有一点需要注意的是读写的顺序要按照写入时的顺序去读，不然会读错数据，布尔类型的参数序列化和反序列时要转换为字符串进行写入和读出。这些步骤做完之后你就可以创建一个该类的对象，并传入到Intent中或者跨进程传递数据 都是可以实现的。

总结

在Android中如果仅在内存中传递数据，应当优先选择使用Parcelable，因为它性能较高，而Serializable在序列化的时候会产生很多临时变量，加大内存压力；而Parcelable不能使用在将对象存储在磁盘上这种情况，因为在外界的变化下Parcelable不能很好的保证数据的持续性；综合来说两者都有其优缺点，我们应该在合适的场合选择合适的方法来进行使用，以达到最大的性能优化。