Android 进阶6：两种序列化方式 Serializable 和 Parcelable

女爷i 2022-06-14 23:16 209阅读 0赞

## 什么是序列化 ##

我们总是说着或者听说着“序列化”，它的定义是什么呢？

> 序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。
> 
> 二进制序列化保持类型保真度，这对于在应用程序的不同调用之间保留对象的状态很有用。例如，通过将对象序列化到剪贴板，可在不同的应用程序之间共享对象。您可以将对象序列化到流、磁盘、内存和网络等等。远程处理使用序列化“通过值”在计算机或应用程序域之间传递对象。

简单地说，“序列化”就是将运行时的对象状态转换成二进制，然后保存到流、内存或者通过网络传输给其他端。

在安卓开发中，我们在组件中传递数据时常常使用 Intent 传输数据时需要传递 Serializable 或者 Parcelable 的数据，比如 Intent.putExtra 方法：

public Intent putExtra(String name, Parcelable value) {
       ...}
    public Intent putExtra(String name, Serializable value) {
       ...}

也会使用 Binder 传递数据。

今天就来介绍下这两种序列化方式。

## 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` 属性的类以及内部类添加一个警告。

![这里写图片描述][SouthEast]

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

![这里写图片描述][SouthEast 1]

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

> 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
         */
        @Override
        public int describeContents() {
            //几乎都返回 0，除非当前对象中存在文件描述符时为 1
            return 0;
        }
    
        /**
         * 2.序列化
         * @param dest
         * @param flags 0 或者 1
         */
        @Override
        public 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
             */
            @Override
            public ParcelableGroupBean createFromParcel(Parcel in) {
                return new ParcelableGroupBean(in);
            }
    
            /**
             * 反序列创建对象数组
             * @param size
             * @return
             */
            @Override
            public 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 底层做了优化处理，效率很高。

## Thanks ##

《Android 开发艺术探索》  
[http://developer.android.com/reference/android/os/Parcelable.html][http_developer.android.com_reference_android_os_Parcelable.html]

[SouthEast]: /images/20220615/79eeeb92b95a481c9ed1c97d67e79945.png
[SouthEast 1]: /images/20220615/12d95156e955421f992835f8da204eb9.png
[http_developer.android.com_reference_android_os_Parcelable.html]: http://developer.android.com/reference/android/os/Parcelable.html