Android 两种序列化方式 Serializable 和 Parcelable

 

什么是序列化

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

序列化 (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 属性的类以及内部类添加一个警告。

这样当我们创建一个类不声明 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
     */
    @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

转自：https://blog.csdn.net/u011240877/article/details/72455715

 

一、序列化、反序列化是什么？

(1) 名词解释

对象的序列化 : 把Java对象转换为字节序列并存储至一个储存媒介的过程。
对象的反序列化:把字节序列恢复为Java对象的过程。

(2) 序列化详细解释

对象的序列化涉及三个点关键点：Java对象、字节序列、存储。

1. Java对象的组成？
Java对象包含变量与方法。但是序列与反序列化仅处理Java变量而不处理方法，序列与反序列化仅对数据进行处理。

2. 什么是字符序列？
字符序列是两个词，字符是在计算机和电信领域中，字符（Character）是一个信息单位。数学上，序列是被排成一列的对象（或事件）。
《字符-维基百科》 ， 《序列-维基百科》 说白了就是连续排列的多个字符的集合。类似于"1A165613246546"

3. 存储
字符序列需要保存到一个地方，可以是硬盘也可以是内存。
简单说法是：序列化把当前对象信息保存下来。反序列化刚好相反的操作。

 

二、Java对象与Java对象序列化的区别？

Java对象存在的前提必须在JVM运行期间存在，如果想在JVM非运行的情况下或者在其他机器JVM上获取指定Java对象，在现有Java对象的机制下都不可能完成。
与Java对象不同的是，如果对Java对象执行序列化操作，因为原理是把Java对象信息保存到存储媒介，所以可以在以上Java对象不可能存在的两种情况下依然可以使用Java对象。

 

三、为什么要使用序列化、反序列化？

根据以上对序列化、反序列化的理解，这个疑问可以翻译成，为什么需要把对象信息保存到存储媒介中并之后读取出来？
因为二中的解释，开发中有在JVM非运行的情况下或者在其他机器JVM上获取指定Java对象的需求。

例如：

1. 使用RMI（远程方法调用）

2. 网络中传递对象（Java Beans）

3. 对象深度复制（包括当前对象包含的对象关系网）

 

四、Android 中Serializable与Parcelable区别？

两种都是用于支持序列化、反序列化话操作，两者最大的区别在于存储媒介的不同，Serializable使用IO读写存储在硬盘上，而Parcelable是直接在内存中读写，很明显内存的读写速度通常大于IO读写，所以在Android中通常优先选择Parcelable。
Serializable不是当前关注的焦点，不过可以查看《Java序列化算法透析》这篇文章中实现一个简单的Serializable例子，查看序列化生成的IO文件，并且以16进制读取并一一解释每一个16进制数字的含义。

 

五、Parcelable举例

在Android中实现Parcelable接口的类可以支持序列与反序列化，以下是一个实现的举例：
1. 实现Parcelable接口
2. 添加实体属性
3. 覆写writeToParcel(Parcel dest, int flags)方法，指定写入Parcel类的数据。
4. 创建Parcelable.Creator静态对象，有两个方法createFromParcel(Parcel in)与newArray(int size)，前者指定如何从Parcel中读取出数据对象，后者创建一个数组。
5. 覆写describeContents方法，默认返回0。

1. public class Gril implements Parcelable {

2.  

3. private int mAge; // 年龄

4. private boolean mSexy; // 是否性感

5.  

6. @Override

7. public void writeToParcel(Parcel dest, int flags) {

8. dest.writeInt(mAge);

9. dest.writeByte((byte) (mSexy ? 1 : 0));

10. }

11.  

12. public static final Parcelable.Creator<Gril> CREATOR = new Parcelable.Creator<Gril>() {

13. public Gril createFromParcel(Parcel in) {

14. Gril gril = new Gril();

15. gril.mAge = in.readInt();

16. gril.mSexy = in.readByte() != 0;

17. return gril;

18. }

19.  

20. public Gril[] newArray(int size) {

21. return new Gril[size];

22. }

23. };

24.  

25. @Override

26. public int describeContents() {

27. return 0;

28. }

29. }

 

六、Parcelable原理

    从上面的例子中可以看出，具体的写入（dest.writeInt(mAge);）与读取（gril.mAge = in.readInt();）都是针对Parcel对象进行的操作，下面贴出的是Parcle 读写int类型数据的定义。

 

1. public final class Parcel {

2.  

3. ......

4.  

5. /**

6. * Write an integer value into the parcel at the current dataPosition(),

7. * growing dataCapacity() if needed.

8. */

9. public final native void writeInt(int val);

10.  

11. /**

12. * Read an integer value from the parcel at the current dataPosition().

13. */

14. public final native int readInt();

15.  

16. ......

17. }

 

 

从上面代码可以看出都是native方法说明都是使用JNI，其具体位置在system/frameworks/base/core/jni/android_util_Binder.cpp ，以下也仅以int类型读写为例
 

1. static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val)

2. {

3. Parcel* parcel = parcelForJavaObject(env, clazz);

4. if (parcel != NULL) {

5. const status_t err = parcel->writeInt32(val);

6. if (err != NO_ERROR) {

7. jniThrowException(env, "java/lang/OutOfMemoryError", NULL);

8. }

9. }

10. }

11.  

12. static jint android_os_Parcel_readInt(JNIEnv* env, jobject clazz)

13. {

14. Parcel* parcel = parcelForJavaObject(env, clazz);

15. if (parcel != NULL) {

16. return parcel->readInt32();

17. }

18. return 0;

19. }

从上面可以看出都会调用Parcel实现且分别调用writeInt32与readInt32函数，接着来看看具体实现。位置：/system/frameworks/base/libs/binder/Parcel.cpp
 

1. status_t Parcel::writeInt32(int32_t val)

2. {

3. return writeAligned(val);

4. }

5.  

6. template<class T>

7. status_t Parcel::writeAligned(T val) {

8. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

9.  

10. if ((mDataPos+sizeof(val)) <= mDataCapacity) {

11. restart_write:

12. *reinterpret_cast<T*>(mData+mDataPos) = val;

13. return finishWrite(sizeof(val));

14. }

15.  

16. status_t err = growData(sizeof(val));

17. if (err == NO_ERROR) goto restart_write;

18. return err;

19. }

20.  
21.  

22. status_t Parcel::readInt32(int32_t *pArg) const

23. {

24. return readAligned(pArg);

25. }

26.  

27. template<class T>

28. status_t Parcel::readAligned(T *pArg) const {

29. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

30.  

31. if ((mDataPos+sizeof(T)) <= mDataSize) {

32. const void* data = mData+mDataPos;

33. mDataPos += sizeof(T);

34. *pArg = *reinterpret_cast<const T*>(data);

35. return NO_ERROR;

36. } else {

37. return NOT_ENOUGH_DATA;

38. }

39. }

以下4点摘自《探索Android中的Parcel机制（上）》
有兴趣的朋友可以自己读一下，不难理解，这里把基本的思路总结一下：
1. 整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高很多；
2. 读写时是4字节对齐的，可以看到#define PAD_SIZE(s) (((s)+3)&~3)这句宏定义就是在做这件事情；
3. 如果预分配的空间不够时newSize = ((mDataSize+len)*3)/2;会一次多分配50%；

4. 对于普通数据，使用的是mData内存地址，对于IBinder类型的数据以及FileDescriptor使用的是mObjects内存地址。后者是通过flatten_binder()和unflatten_binder()实现的，目的是反序列化时读出的对象就是原对象而不用重新new一个新对象。

 

七、序列化反序列化Parcelable实验？

1. 任何实体类都需要复写Parcelable接口吗？
2. 如果子类新增属性，需要复写父类writeToParcel与CREATOR吗？
3. writeToParcel 与 createFromParcel 对变量的读写前后顺序可以不一致吗，会出现什么结果？
4. 读写Parcelable对象（写操作dest.writeParcelable(obj, flags);  读操作in.readParcelable(ObjectA.class.getClassLoader()); ）
5. 读写Parcelable对象数组

1. dest.writeParcelableArray(mClassNameList.toArray(new ClassName[mClassNameList.size()]), flags);

2.  

3. Parcelable[] parcelableArr = in.readParcelableArray(ClassName.class.getClassLoader());

4. ArrayList<ClassName> arrayList = new ArrayList<ClassName>();

5. for (Parcelable object : parcelableArr) {

6. arrayList.add((ClassName)object);

7. }

 

八、自己实现序列与反序列化机制

《C 语言的数据序列化 （C语言实现序列化机制的思路）》


 

九、参考资料

《探索Android中的Parcel机制（上）》
《探索Android中的Parcel机制（下）》

《Android中的Parcel是什么》
《Android开发：什么是Parcel(2)》