Android学习之Serializable和Parcelable

什么是序列化

序列化本质上就是把对象内存中的数据按照一定规则，变成一系列的字节数据(二进制数据)，然后在把这些字节数据写入到流中。而反序列化的过程相反，先读取字节数据，然后在重新组装成Java对象

序列化的目的

永久的保存对象数据(将对象数据保存在文件当中,或者是磁盘中)
通过序列化操作将对象数据在网络上进行传输(由于网络传输是以字节流的方式对数据进行传输的.因此序列化的目的是将对象数据转换成字节流的形式)
将对象数据在进程之间进行传递(Activity之间传递对象数据时,需要在当前的Activity中对 对象 数据进行序列化操作.在另一个Activity中需要进行反序列化操作讲数据取出)
序列化对象的时候只是针对变量进行序列化,不针对方法进行序列化.
在Intent之间,基本的数据类型直接进行相关传递即可,但是一旦数据类型比较复杂的时候,就需要进行序列化操作了

Android中实现序列化的两种方式

Implements Serializable 接口 (声明一下即可)
Implements Parcelable 接口(不仅仅需要声明,还需要实现内部的相应方法,写入数据的顺序和读出数据的顺序必须是相同的)

Serializable原理

JAVA中的对象流操作是通过 ObjectInputStream和ObjectOutputStream这两个流对象来实现，在两个对象的使用过程中，源码里会判断对象是否实现 Serializable接口，否则会抛出 java.io.NotSerializableException 异常，Serializable也可以自定义，实现 writeObject和readObject方法即可
Serializable只是一个接口，本身没有任何实现
对象的反序列化并没有调用对象的任何构造方法
serialVersionUID是用于记录文件版本信息的，最好能够自定义。否则，系统会自动生成一个serialVersionUID，文件或者对象的任何改变，都会改变serialVersionUID，导致反序列化的失败，如果自定义就没有这个问题。
如果某个属性不想实现序列化，可以采用transient修饰
Serializable的系统实现是采用ObjectInputStream和ObjectOutputStream实现的，这也是为什么调用ObjectInputStream和ObjectOutputStream时，需要对应的类实现Serializable接口。

使用Parcelable进行序列化操作

writeToParcel 将对象数据序列化成一个Parcel对象(序列化之后成为Parcel对象.以便Parcel容器取出数据)
重写describeContents方法,默认值为0
Public static final Parcelable.CreatorCREATOR (将Parcel容器中的数据转换成对象数据) 同时需要实现两个方法:
　　3.1 CreateFromParcel(从Parcel容器中取出数据并进行转换.)
　　3.2 newArray(int size)返回对象数据的大小

Parcelable原理

无论是对数据的读还是写都需要使用Parcel作为中间层将数据进行传递.Parcel涉及到的东西就是与C++底层相关.通过JNI互相调用.在Java应用层是先创建Parcel(Java)对象,然后再调用相关的读写操作的时候.这里以读写32为Int数据来举例子
首先将Parcel(Java)对象转换成Parcel(C++)对象,然后被封装在Parcel中的相关数据由C++底层来完成数据的序列化操作

status_t Parcel::writeInt32(int32_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::continueWrite(size_t desired)
{
 // If shrinking, first adjust for any objects that appear
 // after the new data size.
 size_t objectsSize = mObjectsSize;
 if (desired < mDataSize) {
  if (desired == 0) {
   objectsSize = 0;
  } else {
   while (objectsSize > 0) {
    if (mObjects[objectsSize-1] < desired)
     break;
    objectsSize--;
   }
  }
 }
  
 if (mOwner) {
  // If the size is going to zero, just release the owner's data.
  if (desired == 0) {
   freeData();
   return NO_ERROR;
  }
 
  ...
   
  if (mData) {
   memcpy(data, mData, mDataSize < desired ? mDataSize : desired);
  }
  if (objects && mObjects) {
   memcpy(objects, mObjects, objectsSize*sizeof(size_t));
  }
 ...
 
 } else if (mData) {
  if (objectsSize < mObjectsSize) {
   // Need to release refs on any objects we are dropping.
   const sp<ProcessState> proc(ProcessState::self());
   for (size_t i=objectsSize; i<mObjectsSize; i++) {
    const flat_binder_object* flat
     = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
    if (flat->type == BINDER_TYPE_FD) {
     // will need to rescan because we may have lopped off the only FDs
     mFdsKnown = false;
    }
    release_object(proc, *flat, this);
   }
   size_t* objects =
    (size_t*)realloc(mObjects, objectsSize*sizeof(size_t));
   if (objects) {
    mObjects = objects;
   }
   mObjectsSize = objectsSize;
   mNextObjectHint = 0;
  }
 ...
 }
 
 return NO_ERROR;
}

整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高很多
读写时是4字节对齐的，可以看到#define PAD_SIZE(s) (((s)+3)&~3)这句宏定义就是在做这件事情
如果预分配的空间不够时newSize = ((mDataSize+len)*3)/2;会一次多分配50%
对于普通数据，使用的是mData内存地址，对于IBinder类型的数据以及FileDescriptor使用的是mObjects内存地址。后者是通过flatten_binder()和unflatten_binder()实现的，目的是反序列化时读出的对象就是原对象而不用重新new一个新对象

两个方式如何选择

在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable