Binder相关面试总结（五）：为什么Activity间传递对象需要序列化

前言

我们都知道进行Android 开发的时候，跳转到Activity和Fragment的时候，传递对象是通过Intent或者bundle 进行传递。当这个对象没有实现序列化的时候当你通过Inetnt传递的时候会报红，系统会提示你将这个对象实现序列化。

不同 Activity 之间传输数据可以通过 Intent 对象的 putExtra 方法传递，对于 java 的八大基本数据类型(char int float double long short boolean byte)传递是没有问题的，但是如果传递比较复杂的对象类型（比如对象，比如集合等），那么就可能存在问题，就需要实现数据对象数据序列化, 将这些对象放到一个 Intent 或者 Bundle 里面，然后再传递。

1. 什么是序列化

序列化 Serialization – 将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

简单来说：

序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

2. 为什么要序列化

序列化的原因基本三种情况：

永久性保存对象，保存对象的字节序列到本地文件中；
对象在网络中传递；
对象在 IPC 间传递。

3. Android中的两种序列化机制

实现 Serializable 接口
实现 parcelable 接口

3.1 两种序列化方式的区别：

Serializeble 是 java 的序列化方式，Parcelable 是 Android 特有的序列化方式；
在使用内存的时候，Parcelable 比 Serializable 性能高，所以推荐使用 Parcelable。
Serializable 在序列化的时候会产生大量的临时变量，从而引起频繁的 GC。
Parcelable 不能使用在要将数据存储在磁盘上的情况，因为 Parcelable 不能很好的保证数据的持续性在外界有变化的情况下。尽管 Serializable 效率低点，也不提倡用，但在这种情况下，还是建议你用 Serializable。
Serializeble 序列化的方式比较简单，直接集成一个接口就好了，而 parcelable 方式比较复杂，不仅需要集成 Parcelable 接口还需要重写里面的方法。

3.2 两种序列化的使用

Serializable 接口

Serializable 是 Java 提供的序列化接口，它是一个空接口：

public interface Serializable {
}

Serializable 用来标识当前类可以被 ObjectOutputStream 序列化，以及被 ObjectInputStream 反序列化。

Serializable 有以下几个特点：

可序列化类中，未实现 Serializable 的属性状态无法被序列化/反序列化
也就是说，反序列化一个类的过程中，它的非可序列化的属性将会调用无参构造函数重新创建
因此这个属性的无参构造函数必须可以访问，否者运行时会报错
一个实现序列化的类，它的子类也是可序列化的

下面是一个实现了 Serializable 的实体类：

public class GroupBean implements Serializable {private static final long serialVersionUID = 8829975621220483374L;private String mName;private List<String> mMemberNameList;public GroupBean() {}public String getName() {return mName;}public void setName(String name) {mName = name;}public List<String> getMemberNameList() {return mMemberNameList;}public void setMemberNameList(List<String> memberNameList) {mMemberNameList = memberNameList;}
}

可以看到实现 Serializable 的实现非常简单，除了实体内容外只要创建一个 serialVersionUID 属性就好。

serialVersionUID

从名字就可以看出来，这个 serialVersionUID ，有些类似我们平时的接口版本号，在运行时这个版本号唯一标识了一个可序列化的类。

也就是说，一个类序列化时，运行时会保存它的版本号，然后在反序列化时检查你要反序列化成的对象版本号是否一致，不一致的话就会报错：·InvalidClassException。

如果我们不自己创建这个版本号，序列化过程中运行时会根据类的许多特点计算出一个默认版本号。然而只要你对这个类修改了一点点，这个版本号就会改变。这种情况如果发生在序列化之后，反序列化时就会导致上面说的错误。

因此 JVM 规范强烈建议我们手动声明一个版本号，这个数字可以是随机的，只要固定不变就可以。同时最好是 private 和 final 的，尽量保证不变。

此外，序列化过程中不会保存 static 和 transient 修饰的属性，前者很好理解，因为静态属性是与类管理的，不属于对象状态；而后者则是 Java 的关键字，专门用来标识不序列化的属性。

默认实现 Serializable 不会自动创建 serialVersionUID 属性，为了提示我们及时创建 serialVersionUID ，可以在设置中搜索 serializable 然后选择下图所示的几个选项，为那些没有声明 serialVersionUID 属性的类以及内部类添加一个警告。

这样当我们创建一个类不声明 UID 属性时，类名上就会有黄黄的警告：

鼠标放上去就会显示警告内容：

GroupBean’ does not define a ‘serialVersionUID’ field less… (Ctrl+F1)
Reports any Serializable classes which do not provide a serialVersionUID field. Without a serialVersionUID field, any change to a class will make previously serialized versions unreadable.

这时我们按代码提示快捷键就可以生成 serialVersionUID 了。

序列化与反序列化 Serializable

Serializable 的序列化与反序列化分别通过 ObjectOutputStream 和 ObjectInputStream 进行，实例代码如下：

/*** 序列化对象** @param obj* @param path* @return*/
synchronized public static boolean saveObject(Object obj, String path) {if (obj == null) {return false;}ObjectOutputStream oos = null;try {oos = new ObjectOutputStream(new FileOutputStream(path));oos.writeObject(obj);oos.close();return true;} catch (IOException e) {e.printStackTrace();} finally {if (oos != null) {try {oos.close();} catch (IOException e) {e.printStackTrace();}}}return false;
}/*** 反序列化对象** @param path* @param <T>* @return*/
@SuppressWarnings("unchecked ")
synchronized public static <T> T readObject(String path) {ObjectInputStream ojs = null;try {ojs = new ObjectInputStream(new FileInputStream(path));return (T) ojs.readObject();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();} finally {close(ojs);}return null;
}

Parcelable 接口

Parcelable 是 Android 特有的序列化接口：

public interface Parcelable {//writeToParcel() 方法中的参数，用于标识当前对象作为返回值返回//有些实现类可能会在这时释放其中的资源public static final int PARCELABLE_WRITE_RETURN_VALUE = 0x0001;//writeToParcel() 方法中的第二个参数，它标识父对象会管理内部状态中重复的数据public static final int PARCELABLE_ELIDE_DUPLICATES = 0x0002;//用于 describeContents() 方法的位掩码，每一位都代表着一种对象类型public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;//描述当前 Parcelable 实例的对象类型//比如说，如果对象中有文件描述符，这个方法就会返回上面的 CONTENTS_FILE_DESCRIPTOR//其他情况会返回一个位掩码public int describeContents();//将对象转换成一个 Parcel 对象//参数中 dest 表示要写入的 Parcel 对象//flags 表示这个对象将如何写入public void writeToParcel(Parcel dest, int flags);//实现类必须有一个 Creator 属性，用于反序列化，将 Parcel 对象转换为 Parcelable public interface Creator<T> {public T createFromParcel(Parcel source);public T[] newArray(int size);}//对象创建时提供的一个创建器public interface ClassLoaderCreator<T> extends Creator<T> {//使用类加载器和之前序列化成的 Parcel 对象反序列化一个对象public T createFromParcel(Parcel source, ClassLoader loader);}
}

实现了 Parcelable 接口的类在序列化和反序列化时会被转换为 Parcel 类型的数据。

Parcel 是一个载体，它可以包含数据或者对象引用，然后通过 IBinder 在进程间传递。

实现 Parcelable 接口的类必须有一个 CREATOR 类型的静态变量，下面是一个实例：

public class ParcelableGroupBean implements Parcelable {private String mName;private List<String> mMemberNameList;private User mUser;/*** 需要我们手动创建的构造函数* @param name* @param memberNameList* @param user*/public ParcelableGroupBean(String name, List<String> memberNameList, User user) {mName = name;mMemberNameList = memberNameList;mUser = user;}/*** 1.内容描述* @return*/@Overridepublic int describeContents() {//几乎都返回 0，除非当前对象中存在文件描述符时为 1return 0;}/*** 2.序列化* @param dest* @param flags 0 或者 1*/@Overridepublic void writeToParcel(Parcel dest, int flags) {dest.writeString(mName);dest.writeStringList(mMemberNameList);dest.writeParcelable(mUser, flags);}/*** 3.反序列化*/public static final Creator<ParcelableGroupBean> CREATOR = new Creator<ParcelableGroupBean>() {/*** 反序列创建对象* @param in* @return*/@Overridepublic ParcelableGroupBean createFromParcel(Parcel in) {return new ParcelableGroupBean(in);}/*** 反序列创建对象数组* @param size* @return*/@Overridepublic ParcelableGroupBean[] newArray(int size) {return new ParcelableGroupBean[size];}};/*** 4.自动创建的的构造器，使用反序列化得到的 Parcel 构造对象* @param in*/protected ParcelableGroupBean(Parcel in) {mName = in.readString();mMemberNameList = in.createStringArrayList();//反序列化时，如果熟悉也是 Parcelable 的类，需要使用它的类加载器作为参数，否则报错无法找到类mUser = in.readParcelable(User.class.getClassLoader());}}

小结

可以看到，Serializable 的使用比较简单，创建一个版本号即可；而 Parcelable 则相对复杂一些，会有四个方法需要实现。

一般在保存数据到 SD 卡或者网络传输时建议使用 Serializable 即可，虽然效率差一些，好在使用方便。

而在运行时数据传递时建议使用 Parcelable，比如 Intent，Bundle 等，Android 底层做了优化处理，效率很高。

3.3 如何选择哪种序列化方式

Serializable 的使用比较简单，创建一个版本号即可；而 Parcelable 则相对复杂一些，会有四个方法需要实现。

一般在保存数据到 SD 卡或者网络传输时建议使用 Serializable 即可，虽然效率差一些，好在使用方便。
而在运行时数据传递时建议使用 Parcelable，比如 Intent，Bundle 等，Android 底层做了优化处理，效率很高。

4. 原因

Intent 可以算是四大组件之间的胶水，比如在 Activity1 与 Activity2 之间传递对象的时候，必须要将对象序列化，可是为什么要将对象序列化呢？

Intent 在启动其他组件时，会离开当前应用程序进程，进入 ActivityManagerService 进程 – intent.prepareToLeaveProcess()。这也就意味着，Intent 所携带的数据要能够在不同进程间传输。

首先我们知道，Android 是基于 Linux 系统，不同进程之间的 java 对象是无法传输，所以我们此处要对对象进行序列化，从而实现对象在 应用程序进程 和 ActivityManagerService 进程之间传输。