Android 进阶6:两种序列化方式 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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Android 研究

Android JNI学习(三)——Java与Native相互调用

前面两篇文章简单的介绍了JNI,下面我们就进一步了解下一下JNI的调用原则,要想了解JNI的调用原则, 前面我们说了JNI中的JNIEnv以及Java类型和na...

813
来自专栏Ryan Miao

String的内存模型,为什么String被设计成不可变的

String是Java中最常用的类,是不可变的(Immutable), 那么String是如何实现Immutable呢,String为什么要设计成不可变呢? 前...

29313
来自专栏青玉伏案

ReactiveSwift源码解析(五) SignalProtocol的observe()、Map、Filter延展实现

上篇博客我们对Signal的基本实现以及Signal的面向协议扩展进行了介绍, 详细内容请移步于《Signal中的静态属性静态方法以及面向协议扩展》。并且聊了S...

2547
来自专栏我是攻城师

Java里面volatile关键字修饰引用变量的陷阱

如果我现在问你volatile的关键字的作用,你可能会回答对于一个线程修改的变量对其他的线程立即可见。这种说法没多大问题,但是不够严谨。

562
来自专栏aCloudDeveloper

总结:常用的通用数据处理指令

作者:bakari  时间:2012.4.21 1、 操作数类型 Imm立即操作数 Reg寄存器操作数 Mem内存操作数 2、 操作数寻址方式 立即数寻址 寄存...

1818
来自专栏coder修行路

SocketServer源码学习补充

1363
来自专栏Code_iOS

Objective-C 内存管理(上)学习笔记

这里的“计数”表明必然会有一个东西(变量)来记录引用的变化,而在OC里这个变量就是retainCount;那么还有一个问题就是通过什么方式来操作这个变量,OC里...

482
来自专栏阿杜的世界

Java泛型之类型擦除类型擦除参考资料

学过C++模板的,在使用Java泛型的时候,会感觉到有点不疑问,例如:(1)无法定义一个泛型数组、无法调用泛型参数对象中对应的方法(当然,通过extends关键...

642
来自专栏JetpropelledSnake

Python入门之Python的单例模式和元类

 本章内容     一、单例模式     二、元类 ============================= 一、单例模式   单例模式(Singleton ...

3908
来自专栏微信公众号:Java团长

阿里历年经典Java面试题汇总

当写一个volatile变量时,JMM会把线程对应的本地内存中的共享变量值刷新到主内存。

1012

扫码关注云+社区