什么是序列化
我们在开发过程中，都是面向对象开发的。但是，对于计算机来说，计算机只认识二进制。数据的传输和存储都要通过字节流的方式来进行。所以，如果我们想要在本地持久化存储对象或是在网络上或进程间传输对象，必须首先将对象转换成字节流。将对象转换成字节流的过程，就是所谓的序列化。反序列化就是序列化的反向过程，即将字节流转换成对象的过程。序列化的核心思想就是对象状态的保存与重建。
序列化方式
在android中，有如下序列化方式：
- Serializable序列化
- Parcelable序列化
除了上述两种方式外，还可以通过Json进行序列化（例如fastjson），这里主要对比Serializable和Parcelable这两种序列化方式。
Serializable
Serializable是Java自带的序列化方法。在Java中，提供了一个Serializable接口，它是一个空接口，没有定义任何方法，它仅仅只起到了标记作用。它告诉代码，只要是实现了Serializable接口的类都是可以被序列化的，而真正的序列化动作由系统来完成的。所以，通过Serializable的方式来实现序列化很简单，只要想实现序列化的类实现Serializable接口即可。例如，通过继承Serializable接口来实现一个User对象。
public class SerializableUser implements Serializable {
private String name;
private int age;
public SerializableUser(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
}
Serializable对象可以通过ObjectOutputStream持久化，通过ObjectInputStream读取到内存。具体代码如下。
public void saveSerializableUser(SerializableUser user) {
try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(getFilesDir().getAbsolutePath() + "/user.txt"));
out.writeObject(user);
out.close();
}catch (Exception e) {
e.printStackTrace();
}
}
public SerializableUser getSerializableUser(){
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream( getFilesDir().getAbsolutePath() + "/user.txt"));
SerializableUser user = (SerializableUser) in.readObject();
in.close();
return user;
}catch (Exception e) {
e.printStackTrace();
}
return null;
}
例如，在ActvityA中持久化存储一个User对象，然后启动ActivityB并在ActivityB中将ActivityA中持久化存储的对象读取到内存中。代码如下。
// ActivityA
public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_start_activityb:
startActivityB();
break;
case R.id.btn_save_user:
saveSerializableUser(new SerializableUser("xmh",18));
break;
default:
break;
}
}
private void startActivityB() {
Intent intent = new Intent(this, MainActivityB.class);
startActivity(intent);
}
//ActivityB
public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_read_user:
SerializableUser user = getSerializableUser();
Log.d(TAG, "name: " + user.getName() + ", age: " + user.getAge());
break;
default:
break;
}
}
在ActivityA中先保存User对象，然后启动ActivityB，在ActvityB中点击读取按钮，此时可以看到logcat中日志如下：
2022-02-27 20:02:42.495 675-675/com.example.parcelabletest D/MainActivityB: name: xmh, age: 18
通过日志，我们可以看到序列化和反序列化都成功了。
在开发过程中，类的结构并非是固定不变的。例如，当App V1版本发布的时候，User中只包含两个属性，即name和age，安装了App V1版本的用户会在本地持久化存储User对象，当App升级到V2版本的时候，新的业务需求需要在User类中增加一个userId，用于唯一标识一个用户，当用户用App V2版本覆盖安装时，会存在一个问题：用户本地持久化的User对象V1版本的User对象，而当用户使用V2版本对User对象进行反序列化的时候，使用的是带userId的User类进行反序列化，也就是说反序列化时，类的结构发生了变化。这时候会发生什么？我们可以在SerializableUser类中新增userId属性，并增加对应的get和set方法，然后我们在启动ActivityB之前不存储User对象，而是直接启动（本地已经持久化了一个User对象），然后再ActivityB中反序列化本地存储的User对象，发现程序发生了异常，异常信息如下所示。
2022-02-27 20:25:37.209 3580-3580/com.example.parcelabletest D/MainActivityB: getSerializableUser: com.example.parcelabletest.SerializableUser; local class incompatible: stream classdesc serialVersionUID = 3615204604863452229, local class serialVersionUID = 5315681738373527338
这里的异常信息提示很明确，就是反序列化的类和之前序列化的类不兼容，因为我们改了类的结构。同时，这里还提到了一个名词serialVersionUID，这个serialVersionUID是什么，刚才的类中明明没有写任何关于serialVersionUID的东西。
serialVersionUID
serialVersionUID是用来辅助序列化和反序列化的，它用来标识反序列化的时候，类的结构是否发生了变化。在序列化时，系统会将serialVersionUID也写入序列化文件中，然后反序列化时再用当前类中的serialVersionUID和文件中的serialVersionUID对比，如果两个serialVersionUID相同说明序列化的类的版本和当前的类的版本一样，可以成功反序列化。否则，说明当前的类相比于序列化时的类发生了某些变化。比如成员变量的数量，类型可能发生了变化，这个时候是不能正常进行反序列化的。
如果在类中没有手动设置serialVersionUID的值，系统会自动根据当前类的结构计算hash值作为serialVersionUID，如果类的结构发生了变化，那么系统计算出来的serialVersionUID自然就不一样，这样反序列化就会失败。现在，回过来去看之前系统抛出的异常，我们就可以知道原因了。
那么如果我们在代码中手动设置了serialVersionUID，会发生什么呢？我们在User类中新增一个serialVersionUID属性，serialVersionUID可以设置为任意值，例如，写成1，不过这里我们利用Android Studio来生成当前类的serialVersionUID，添加serialVersionUID后，User类如下所示。
public class SerializableUser implements Serializable {
private static final long serialVersionUID = 3615204604863452229L;
private String name;
private int age;
public SerializableUser(String name, int age) {
this.name = name;
this.age = age;
}
…………
}
然后先将新的User对象进行持久化，持久化之后，再按照之前的方式在User类中添加userId属性后，直接对之前持久化的User对象进行反序列化，此时我们看到打印的日志如下所示。
2022-02-27 20:51:49.161 7412-7412/com.example.parcelabletest D/MainActivityB: name: xmh, age: 18
通过日志可以看到，反序列化成功了，这就是serialVersionUID的作用，当手动设定以后，就可以很大程度上避免反序列化的失败。程序能够最大限度地恢复数据。但是在某些情况下，如果类的结构发生了非常规的改变，即使serialVersionUID相同，也无法反序列化，例如，类名发生了变化。所以，在平常开发过程中，最好手动设置serialVersionUID的值，否则只要类的结构稍微发生点改变，都会导致反序列化失败。
另外有两点需要注意：
- 静态成员变量属于类，不属于对象，不参与序列化的过程。
- 使用transient关键字修饰的成员变量不参与序列化的过程。
以上就是使用Serializable进行序列化时的用法。
Parcelable
Parcelable是Android提供的新的序列化的方式，Parcelable也是一个接口，但是通过Parcelable进行序列化要比通过Serializable进行序列化复杂。使用Parcelable进行序列化的时候，除了实现Parcelable接口外，还需要要实现中的describeContents()，writeToParcel(Parcel dest, int flags)，并添加一个静态成员变量CREATOR，这个变量需要实现Parcelable.Creator接口。
describeContents()
返回内容描述，基本在所有情况下，返回0即可。
writeToParcel(Parcel dest, int flags)
这个方法完成序列化的过程，将当前对象写入序列化结构中，内部是通过Parcel一系列的write方法来完成序列化的，flag一般情况下都是0。
CREATOR
一个实现了Parcelable.Creator接口的匿名内部类，在Parcelable.Creator接口内有createFromParcel和newArray两个方法来完成反序列化操作。createFromParcel用于从序列化后的对象中创建原始对象，newArray方法用于创建指定长度的原始对象的数组。
通过Parcelable来实现User序列化的代码如下。
public class ParcelableUser implements Parcelable {
private String name;
private int age;
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;
}
public ParcelableUser(String name, int age) {
this.name = name;
this.age = age;
}
private ParcelableUser(Parcel parcel) {
name = parcel.readString();
age = parcel.readInt();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
public static Parcelable.Creator<ParcelableUser> CREATOR = new Parcelable.Creator<ParcelableUser>() {
@Override
public ParcelableUser createFromParcel(Parcel source) {
return new ParcelableUser(source);
}
@Override
public ParcelableUser[] newArray(int size) {
return new ParcelableUser[size];
}
};
}
需要注意的是，在Parcelable进行序列化和反序列化的时候，都是按照顺序进行的，什么叫做按照顺序呢？以上面的User对象为例，在writeToParcel方法中，我们依次写入了name，age。
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
在createFromParcel方法中，我们要按照写入时的顺序来读，如下所示。
@Override
public ParcelableUser createFromParcel(Parcel source) {
return new ParcelableUser(source);
}
private ParcelableUser(Parcel parcel) {
name = parcel.readString();
age = parcel.readInt();
}
如果反序列化的时候读取的顺序和写入的顺序不一致，name反序列化就会出错。
Serializable和Parcelable区别
Serializable是Java中的序列化接口，其使用简单方便，但是开销比较大，序列化和反序列化的过程中会用到反射，还会产生很多临时变量，引起GC。在Android中，Serializable一般用于持久化存储数据。
Parcelable是Android中独有的序列化方式，其使用相当Serializable来说比较麻烦，但是效率比较高，所以在内存中传递数据时推荐使用Parcelable，比如Andro中Activity间传递数据或者在进程间传递数据。但是，因为不同版本Parcelable实现不同，因此不推荐使用Parcelable进行持久化存储。
