序列化之Serializable
上篇文章写了Serializable，本篇则介绍Parcelable
Serializable是java的序列化方式，Parcelable是Android中推荐使用的方式，采用共享内存的方式实现用户空间和内核空间的交换，性能很好，但是实现方式比较复杂。
| Parcelable | Serizlizable |
|---|---|
| Parcelable | Serizlizable |
| 实现Parcelable接口 | 实现Serizlizable接口 |
| android 专用 | Java 自带 |
| 内存消耗：低 | 内存消耗：一般 |
| 内存中直接进行读写 | 通过使用IO流的形式将数据读写入在硬盘上 |
| 不支持持久化 | 支持持久化 |
| 速度快 | 速度一般 |
速度上，Parcelable 比 Serializable快了10多倍
parcelable vs serializable
对比总结：
- 在使用内存的时候，Parcelable 类比Serializable性能高，推荐使用Parcelable类。
- Serializable在序列化的时候采用了大量的反射，并且会产生大量的临时变量，从而产生过高的负载，而Parcelable没有这种情况。
- Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点， 但在这种情况下，还是要用Serializable 。
Parcelable实现类介绍
在该篇文章中，介绍了Parcelable对象的快速生成，这里就不再赘述，下面Source 类是一个标准的实现了Parcelable的类：
public class Source implements Parcelable {
private String name;
private String type;
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(this.name);
dest.writeString(this.type);
}
public Source() {
}
protected Source(Parcel in) {
this.name = in.readString();
this.type = in.readString();
}
public static final Creator<Source> CREATOR = new Creator<Source>() {
@Override
public Source createFromParcel(Parcel source) {
return new Source(source);
}
@Override
public Source[] newArray(int size) {
return new Source[size];
}
};
}
describeContents
实现Parcelable的类都需要实现这个方法，返回值一般都是0，但特殊情况下（包含 file descriptor时）需要返回1。
就是Parcelable中定义的变量。
/**
* 表示 Parcelable 对象的扁平化表示包括文件描述符。
*/
public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;
writeToParcel
writeToParcel是正在序列化的方法，内部会通过Parcel中的writeXXX方法，最终调用nativeWritexxx方法，将数据写入。
参数为Parcel的构造函数
通过Parcel的readxxx的方法，进行反序列化，顺序要和写入保持一致
CREATOR
提供方法，创建列化对象和创建对象数组
Parcel
Parcelable使用了Parcel的read和write方法，来进行序列化和反序列化。Parcel调用jni方法，将数据写入和读出。
Parce提供了基本数据类型、String的写入和读出，及其数组，和java标准集合类等。
writeValue涵盖了所有支持的类型。
public final void writeValue(@Nullable Object v) {
if (v == null) {
writeInt(VAL_NULL);
} else if (v instanceof String) {
writeInt(VAL_STRING);
writeString((String) v);
} else if (v instanceof Integer) {
writeInt(VAL_INTEGER);
writeInt((Integer) v);
} else if (v instanceof Map) {
writeInt(VAL_MAP);
writeMap((Map) v);
} else if (v instanceof Bundle) {
// Must be before Parcelable
writeInt(VAL_BUNDLE);
writeBundle((Bundle) v);
} else if (v instanceof PersistableBundle) {
writeInt(VAL_PERSISTABLEBUNDLE);
writePersistableBundle((PersistableBundle) v);
} else if (v instanceof Parcelable) {
// IMPOTANT: cases for classes that implement Parcelable must
// come before the Parcelable case, so that their specific VAL_*
// types will be written.
writeInt(VAL_PARCELABLE);
writeParcelable((Parcelable) v, 0);
} else if (v instanceof Short) {
writeInt(VAL_SHORT);
writeInt(((Short) v).intValue());
} else if (v instanceof Long) {
writeInt(VAL_LONG);
writeLong((Long) v);
} else if (v instanceof Float) {
writeInt(VAL_FLOAT);
writeFloat((Float) v);
} else if (v instanceof Double) {
writeInt(VAL_DOUBLE);
writeDouble((Double) v);
} else if (v instanceof Boolean) {
writeInt(VAL_BOOLEAN);
writeInt((Boolean) v ? 1 : 0);
} else if (v instanceof CharSequence) {
// Must be after String
writeInt(VAL_CHARSEQUENCE);
writeCharSequence((CharSequence) v);
} else if (v instanceof List) {
writeInt(VAL_LIST);
writeList((List) v);
} else if (v instanceof SparseArray) {
writeInt(VAL_SPARSEARRAY);
writeSparseArray((SparseArray) v);
} else if (v instanceof boolean[]) {
writeInt(VAL_BOOLEANARRAY);
writeBooleanArray((boolean[]) v);
} else if (v instanceof byte[]) {
writeInt(VAL_BYTEARRAY);
writeByteArray((byte[]) v);
} else if (v instanceof String[]) {
writeInt(VAL_STRINGARRAY);
writeStringArray((String[]) v);
} else if (v instanceof CharSequence[]) {
// Must be after String[] and before Object[]
writeInt(VAL_CHARSEQUENCEARRAY);
writeCharSequenceArray((CharSequence[]) v);
} else if (v instanceof IBinder) {
writeInt(VAL_IBINDER);
writeStrongBinder((IBinder) v);
} else if (v instanceof Parcelable[]) {
writeInt(VAL_PARCELABLEARRAY);
writeParcelableArray((Parcelable[]) v, 0);
} else if (v instanceof int[]) {
writeInt(VAL_INTARRAY);
writeIntArray((int[]) v);
} else if (v instanceof long[]) {
writeInt(VAL_LONGARRAY);
writeLongArray((long[]) v);
} else if (v instanceof Byte) {
writeInt(VAL_BYTE);
writeInt((Byte) v);
} else if (v instanceof Size) {
writeInt(VAL_SIZE);
writeSize((Size) v);
} else if (v instanceof SizeF) {
writeInt(VAL_SIZEF);
writeSizeF((SizeF) v);
} else if (v instanceof double[]) {
writeInt(VAL_DOUBLEARRAY);
writeDoubleArray((double[]) v);
} else {
Class<?> clazz = v.getClass();
if (clazz.isArray() && clazz.getComponentType() == Object.class) {
// Only pure Object[] are written here, Other arrays of non-primitive types are
// handled by serialization as this does not record the component type.
writeInt(VAL_OBJECTARRAY);
writeArray((Object[]) v);
} else if (v instanceof Serializable) {
// Must be last
writeInt(VAL_SERIALIZABLE);
writeSerializable((Serializable) v);
} else {
throw new RuntimeException("Parcel: unable to marshal value " + v);
}
}
}
Parcel内部维持了一个缓存，因此建议使用Parcel.obtain()来获取Parcel
Parce包含大量write、read、native方法，native通过一个指针对数据进行读和写，通过不同的
要进一步分析Parcels的工作原理，涉及到binder机制
网友评论