android对象序列化Parcelable浅析

一、android序列化简介

我们已经知道在Android使用Intent/Bindler进行IPC传输数据时，需要将对象进行序列化。

JAVA原本已经提供了Serializable接口来实现序列化，使用起来非常简单，主要用于对象持久化以及对象的网络传输。Serializable开销比较大，因为序列化和反序列化的过程需要大量的I/O操作。

Android提供了Parcelable对象序列化操作是内存序列化，主要用于Intent/Bindler的IPC数据传输。

二、Parcelable序列化使用方法

比如我们使用Parcelable在两个activity直接通过intent进行传输一个Book的对象。

 package org.xerrard.demo2;

 import android.os.Parcel;
 import android.os.Parcelable;

 /**
  * Created by xuqiang on 16-1-20.
  */
 public class Book implements Parcelable{

     public String bookname;

     public Book(String bookname){
         this.bookname = bookname;
     }

     protected Book(Parcel in) {
         bookname = in.readString();
     }

     public static final Creator<Book> CREATOR = new Creator<Book>() {
         @Override
         public Book createFromParcel(Parcel in) {
             return new Book(in);
         }

         @Override
         public Book[] newArray(int size) {
             return new Book[size];
         }
     };

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(Parcel dest, int flags) {
         dest.writeInt(bookname);
     }
 }

我们需要完成以下几部。

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

然后我们就可以使用Intent中的putExtra方法将Book对象写入Intent中，然后使用getExtra方法，就可以从Intent中读出Book对象。

三、Parcelable底层序列化原理

从上面的例子可以看到，Parcelable的序列化方式使用起来还是比较麻烦的。但是，这种方式效率上是比较好的，因为Parcelable的序列化过程是再底层native通过内存操作实现的。

详细的JNI和C/C++底层的内存操作可以看这篇文章探索Android中的Parcel机制（上）

摘抄里面最重要的一句结论

整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高很多

因此，在IPC过程中，android推荐使用Parcelable序列化方式

四：Parcelable的调用关系

我们知道如果要使用Parcelable，必须按照要求实现这五项操作

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

这里面又是怎样的调用关系呢？

我们看到，writeToParcel是在startActivity的过程中由intent->Bundle->Parcel 一步一步的调用的，然后WriteToParcel会调用native方法，在底层做序列化操作

而createFromParcel是在收到Intent之后，由Intent->Bundle->Parcel 一步一步的调用。

由此可以看出，Parcel的填包解包都是离不开Bundle的。

这里其实还是有一个疑问，这个Creator是怎么一回事呢？

我们从源码中截取Creator这部分来看看。

     public final <T extends Parcelable> T readParcelable(ClassLoader loader) {
         Parcelable.Creator<T> creator = readParcelableCreator(loader);
         if (creator == null) {
             return null;
         }
         if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
             return ((Parcelable.ClassLoaderCreator<T>)creator).createFromParcel(this, loader);
         }
         return creator.createFromParcel(this);
     }

     /** @hide */
     public final <T extends Parcelable> T readCreator(Parcelable.Creator<T> creator,
             ClassLoader loader) {
         if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
             return ((Parcelable.ClassLoaderCreator<T>)creator).createFromParcel(this, loader);
         }
         return creator.createFromParcel(this);
     }

     /** @hide */
     public final <T extends Parcelable> Parcelable.Creator<T> readParcelableCreator(
             ClassLoader loader) {
         String name = readString(); //此处获得类名，还不太清楚如何获得的，如果想深入学习可以再研究
         if (name == null) {
             return null;
         }
         Parcelable.Creator<T> creator;
         synchronized (mCreators) {
             HashMap<String,Parcelable.Creator> map = mCreators.get(loader);
             if (map == null) {
                 map = new HashMap<String,Parcelable.Creator>();
                 mCreators.put(loader, map);
             }
             creator = map.get(name);
             if (creator == null) {
                 try {
                     Class c = loader == null ?
                         Class.forName(name) : Class.forName(name, true, loader);
                     Field f = c.getField("CREATOR");
                     creator = (Parcelable.Creator)f.get(null);
                 }
                 catch (IllegalAccessException e) {
                     Log.e(TAG, "Illegal access when unmarshalling: "
                                         + name, e);
                     throw new BadParcelableException(
                             "IllegalAccessException when unmarshalling: " + name);
                 }
                 catch (ClassNotFoundException e) {
                     Log.e(TAG, "Class not found when unmarshalling: "
                                         + name, e);
                     throw new BadParcelableException(
                             "ClassNotFoundException when unmarshalling: " + name);
                 }
                 catch (ClassCastException e) {
                     throw new BadParcelableException("Parcelable protocol requires a "
                                         + "Parcelable.Creator object called "
                                         + " CREATOR on class " + name);
                 }
                 catch (NoSuchFieldException e) {
                     throw new BadParcelableException("Parcelable protocol requires a "
                                         + "Parcelable.Creator object called "
                                         + " CREATOR on class " + name);
                 }
                 catch (NullPointerException e) {
                     throw new BadParcelableException("Parcelable protocol requires "
                             + "the CREATOR object to be static on class " + name);
                 }
                 if (creator == null) {
                     throw new BadParcelableException("Parcelable protocol requires a "
                                         + "Parcelable.Creator object called "
                                         + " CREATOR on class " + name);
                 }

                 map.put(name, creator);
             }
         }

         return creator;
     }

重点看粗体部分的代码——真想大白：

在接收端收到parcel之后，解析的时候，会通过反射去获取对象的Creator，然后保存到一个hashmap中。然后调用Creator的createFromParcel方法来实现解包。

反射在源码中也是无处不在！