android数据序列化

什么是序列化

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

简单地说,“序列化”就是将运行时的对象状态转换成二进制,然后保存到流、内存或者通过网络传输给其他端。 在安卓开发中,我们在组件中传递数据时常常使用 Intent 传输数据时需要传递 Serializable 或者 Parcelable 的数据,比如 Intent.putExtra 方法:

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

也会使用 Binder 传递数据。

Serializable 接口

Serializable 是 Java 提供的序列化接口,它是一个空接口:

1
2
public interface Serializable {
}

Serializable 用来标识当前类可以被 ObjectOutputStream 序列化,以及被 ObjectInputStream 反序列化。 Serializable 有以下几个特点:

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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 属性的类以及内部类添加一个警告: setting->Editor->Inspections->搜索serializable->勾选:

  • Serializable class without’readObject()’ and ‘writeObject()’
  • Serializable class without’seriaVersionUID’
  • Serializable not-‘static’ inner class with not-Serializable outer class
  • Serializable object implicitly stores non-Serializable Object

这样当我们创建一个类不声明 UID 属性时,类名上就会有黄黄的警告,鼠标放上去就会显示警告内容:

1
2
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 进行,实例代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
**
* 序列化对象
*
* @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 特有的序列化接口:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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 类型的静态变量,下面是一个实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
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());
}

}

Parcelable原理

Parcelable具体的写入(dest.writeInt(mAge);)与读取(gril.mAge = in.readInt();)都是针对Parcel对象进行的操作,下面贴出的是Parcle 读写int类型数据的定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public final class Parcel {

......

/**
* Write an integer value into the parcel at the current dataPosition(),
* growing dataCapacity() if needed.
*/
public final native void writeInt(int val);

/**
* Read an integer value from the parcel at the current dataPosition().
*/
public final native int readInt();

......
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val)
{
Parcel* parcel = parcelForJavaObject(env, clazz);
if (parcel != NULL) {
const status_t err = parcel->writeInt32(val);
if (err != NO_ERROR) {
jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
}
}
}

static jint android_os_Parcel_readInt(JNIEnv* env, jobject clazz)
{
Parcel* parcel = parcelForJavaObject(env, clazz);
if (parcel != NULL) {
return parcel->readInt32();
}
return 0;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
status_t Parcel::writeInt32(int32_t val)
{
return writeAligned(val);
}

template<class T>
status_t Parcel::writeAligned(T val) {
COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

if ((mDataPos+sizeof(val)) <= mDataCapacity) {
restart_write:
*reinterpret_cast<T*>(mData+mDataPos) = val;
return finishWrite(sizeof(val));
}

status_t err = growData(sizeof(val));
if (err == NO_ERROR) goto restart_write;
return err;
}


status_t Parcel::readInt32(int32_t *pArg) const
{
return readAligned(pArg);
}

template<class T>
status_t Parcel::readAligned(T *pArg) const {
COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));

if ((mDataPos+sizeof(T)) <= mDataSize) {
const void* data = mData+mDataPos;
mDataPos += sizeof(T);
*pArg = *reinterpret_cast<const T*>(data);
return NO_ERROR;
} else {
return NOT_ENOUGH_DATA;
}
}

基本的思路总结一下:

  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一个新对象。

问题

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

    总结

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

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

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

参考

坚持原创技术分享,您的支持将鼓励我继续创作!