Parcelable最强解析

这两天有个同事在使用泛型的过程中，T extends BaseBean,对BaseBean类实现了parceable接口，当一个Activity中跳转到另一个Activity的时候，intent.putExtra("key",childBean)，用到ChildBean对象，该类直接继承了BaseBean，他觉得在另外一个Acitivty拿不到ChildBean中的数据信息，甚至当他在用ChildBean=getIntent().getParcelableExtra()的时候出现了类型转换错误，用BaseBean=getIntent().getParcelableExtra()确没有问题，一时间对父类实现parcelable接口，子类是否有必要实现parcelable接口，然后传值产生了争议，相信也有不少同学也有这样的困惑，所以有了这篇文章

(这里的Basebean和ChildBean是指父类和子类，正文的也是这个意思)

1.Java serialization algorithm

答：当我们对一个对象实现Serializable 接口的时候，它会告诉序列化机制这个类是可以序列化的，java会通过文件流的形式，将object写在一个文件file当中，

public static void main(String args[]) throws IOException {FileOutputStream fos = new FileOutputStream("temp.out");ObjectOutputStream oos = new ObjectOutputStream(fos);TestSerial ts = new TestSerial();oos.writeObject(ts);oos.flush();oos.close(); } 复制代码

这里我们要注意ObjectOutputStream的构造对象，会写如流的header，在这里注意下code后面的注释，因为在例子上面都要给对上的。

public ObjectOutputStream(OutputStream out) throws IOException {verifySubclass();......writeStreamHeader();.....} 复制代码protected void writeStreamHeader() throws IOException {bout.writeShort(STREAM_MAGIC);//这里写入序列化协议bout.writeShort(STREAM_VERSION);//这里写入序列化的版本} 复制代码protected void writeStreamHeader() throws IOException {bout.writeShort(STREAM_MAGIC);bout.writeShort(STREAM_VERSION);} 复制代码

具体的实现是在：

private void writeObject0(Object obj, boolean unshared) throws IOException{······else if (obj instanceof Serializable) {writeOrdinaryObject(obj, desc, unshared);} ···········} 复制代码

如上面代码所示，刚开始的时候，对象是一个Serializable，所以会走writeOrdinaryObject(obj, desc, unshared);方法：

private void writeOrdinaryObject(Object obj,ObjectStreamClass desc,boolean unshared) throws IOException{······try {desc.checkSerialize();bout.writeByte(TC_OBJECT);//这里写入TC_OBJECTwriteClassDesc(desc, false);//接着写classDesc······} finally {if (extendedDebugInfo) {debugInfoStack.pop();}}} 复制代码

上面再写入TC_OBJECT之后，就调用writeClassDesc方法，在这里我就不继续分析了，因为文章的重点不应该在Serializable的分析上，接下来都是些java代码的调用，也有源码，如果你自己感兴趣，相信你们也可以随便看看源代码就能分析出来，在这里我就不浪费大家的时间了，不过要提一下，写的时候，是先写自身类的描述，然后如果有父类就写父类的描述，如果自身类包含的字段是一个对象，再写该对象的描述，都写完了，最后写字段的数据。在这里对一个类获取里面的字段，方法等是用到了反射机制
以下是一个对象写入的例子,假设一个类是:

class TestSerial implements Serializable {public byte version = 100; } 复制代码

如上一个对象所示，在写入磁盘的时候，保存的数据如下：

AC ED （序列化协议） 00 05 （序列化版本） 73 (TC_OBJECT. 新的对象） 72 (TC_CLASSDESC. 这是一个新类描述） 00 0A (类名的长度） 53 65 72 69 61 6C 54 65 73 74 (类的名称) 05 52 81 5A AC 66 02 F6 (SerialVersionUID） 02 (Various flags,0x02代表这个对象支持序列化） 00 01 (类有几个字段） 49 (代表是int类型) 00 07 (字段名称的长度） 76 65 72 73 69 6F 6E (version, 字段的名称) 78 (TC_ENDBLOCKDATA, 描述的结束符) 70 (TC_NULL) 00 00 00 64 (version的值) 复制代码

从上面可以看到serialiable的序列化和反序列化会创造大量的对象和写入数据的时候，会写入除去真实数据以外的其它数据，比如序列化协议，版本等等。

2.Parcable 机制的原理？

首先我们在一个实体对象在实现parcelable的时候，这个时候，我们会重写writeToParcel方法，其中执行dest.writeInt(this.offLineBtn);writeLong等等类型的数据，实际是执行native方法，在这里我们就不分析各种数据类型的存取了，我们现在拿一个代表int来分析下，看下jni方法：

static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jint nativePtr, jint val) {Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);const status_t err = parcel->writeInt32(val);if (err != NO_ERROR) {signalExceptionForError(env, clazz, err);} } 复制代码

在这里我们要特别注意两个参数，一个是之前传上去的指针以及需要保存的int数据，这两个值分别是： (jint nativePtr, jint val) 首先是根据这个指针，这里说一下，指针实际上就是一个整型地址值，所以这里使用强转将int值转化为parcel类型的指针是可行的，然后使用这个指针来操作native的parcel对象，即： const status_t err = parcel->writeInt32(val);

writeInt32是调用了parcel中的方法，parcel的实现类是在Framework/native/libs\binder\Parcel.cpp，我们看下writeInt32方法:

status_t Parcel::writeInt32(int32_t val) {return writeAligned(val); } 复制代码status_t Parcel::writeAligned(T val) {COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(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; } 复制代码

分析上面的之前，首先要知道mData、mDataPos、mDataCapacity三个变量的意义，mData指向parcel缓存的首地址，mDataCapacity表示parcel缓存容量（大小），mDataPos指向parcel缓存中空闲区域的首地址，整个parcel缓存是一块连续的内存。
物理地址 = 有效地址+偏移地址，首先会判断先写入的int数据的字节数是否超过了data的容量，如果没有超过，会执行数据的写入，reinterpret_cast是c++的一种再解释，强制转换，上面首先会将mData+mDataPos得到物理地址，转成指向T类型的指针（T类型就是你传进来的变量的类型），然后将val赋值给指针指向的内容。然后修改偏移地址，finishWrite(sizeof(val))：

status_t Parcel::finishWrite(size_t len) {if (len > INT32_MAX) {// don't accept size_t values which may have come from an// inadvertent conversion from a negative int.return BAD_VALUE;}//printf("Finish write of %d\n", len);mDataPos += len;ALOGV("finishWrite Setting data pos of %p to %zu", this, mDataPos);if (mDataPos > mDataSize) {mDataSize = mDataPos;ALOGV("finishWrite Setting data size of %p to %zu", this, mDataSize);}//printf("New pos=%d, size=%d\n", mDataPos, mDataSize);return NO_ERROR; } 复制代码

上面主要是将修改偏移地址，将偏移地址加上新增加的数据的字节数。
如果增加的数据大于容量的话，那么首先扩展parcel的缓存空间，growData(sizeof(val))：

status_t Parcel::growData(size_t len) {if (len > INT32_MAX) {// don't accept size_t values which may have come from an// inadvertent conversion from a negative int.return BAD_VALUE;}size_t newSize = ((mDataSize+len)*3)/2;return (newSize <= mDataSize)? (status_t) NO_MEMORY: continueWrite(newSize); } 复制代码

扩展成功，就继续goto restart_write，在writeAligned方法中有restart_write，执行restart_write后面code，写入数据。

通过上面的解释相信大家已经明白int类型的数据写入parcel缓存了，既然知道存数据，那我们也要明白取数据了，在取数据的时候，我们会通过this.age = in.readInt();来取得int类型数据

static jint android_os_Parcel_readInt(jlong nativePtr) {Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);if (parcel != NULL) {return parcel->readInt32();}return 0; } 复制代码

调用的parcel的readInt32方法：

int32_t Parcel::readInt32() const {return readAligned<int32_t>(); } 复制代码T Parcel::readAligned() const {T result;if (readAligned(&result) != NO_ERROR) {result = 0;}return result; } 复制代码status_t Parcel::readAligned(T *pArg) const {COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE_UNSAFE(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;} } 复制代码

读取数据的时候，首先我们会从parcel的起始地址+parcel偏移地址，得到读取的数据的地址，然后取出数据，然后将parcel的偏移地址+取出的数据的字节数，这样指针就可以指向下一个数据，这样说太抽象了，举个例子： 比如我们现在有一个对象，里面是

stu{int age = 32;double score = 99; } 复制代码

我们在写数据的时候，会在一块parcel的内存地址中，写32,99，然后读取的时候，会从起始地址+读取的字节数，来一一读取，首先读取parcel起始地址指向的数据，取出32，然后将指针地址偏移int字节数，指针指向99的地址，然后读取99，然后取出数据，这也就是parcelable在实现的时候为什么需要存和读取的顺序需要一致的原因。

3.在我们了解了，parcelable的实现原理的时候，我们就可以解答引言上面的问题了。

3.1 对BaseBean类实现了parceable接口，当一个Activity中跳转到另一个Activity的时候，intent.putExtra("key",childBean)，另一个Activity能否用拿到数据？

答：因为在父类的BaseBean里面都有实现BaseBean中字段的读写，所以BaseBean中字段的数据是可以拿到的。

3.2 在用ChildBean=getIntent().getParcelableExtra()的时候出现了类型转换错误,用BaseBean=getIntent().getParcelableExtra()确没有问题?

答：其实这里是要看BaseBean中读数据，返回的对象是什么了？

public static final Parcelable.Creator<BaseBean> CREATOR = new Parcelable.Creator<BaseBean>() {@Overridepublic BaseBean createFromParcel(Parcel source) {return new BaseBean(source);}@Overridepublic BaseBean[] newArray(int size) {return new BaseBean[size];}}; 复制代码

很明显，在这里返回的BaseBean的对象，当你用ChildBean去接收的时候肯定会出现类型转换错误啦，如果还觉得想用ChildBean来接收的话(前提是有强迫症),可以重写createFromParcel方法

@Overridepublic BaseBean createFromParcel(Parcel source) {ChildBean childBean = new ChildBean();childBean.setName(source.readString());childBean.setPrice(source.readDouble());return childBean;} 复制代码

这不返回ChildBean不就可以了，当然不管你是哪种方式，如果childBean没有实现parceable的话，对于childBean中的字段是无法传递的.
attention:这个和Serializable的实现是不同的，Serializable是父类实现了Serializable，子类不需要实现Serializable，子类的数据也能够传递了，因为在写入数据的判断（obj instanceof Serializable）,如果父类实现Serializable,子类肯定也是instanceof Serializable。

3.3 如果我们需要用到一个公共的界面，这个公共的界面可能是通过泛型T t =getIntent().getParcelableExtra()来获取数据的解决方案？

答：这里我们的BaseBean不应该是一个类，最合适的话，应该是一个interface，比如我们公共界面是用到了t.getName()来得到显示的数据，这个时候

class ChildBean implements BaseBean,Parcelable{...@Overridepublic String getName(){return "WelliJohn";}... } 复制代码

当用到了传值的时候，ChildBean再自身实现了Parcelable接口，这样代码就完美了。这样如果真的在公共界面有个特殊的类型的话，判断下T的类型(ChildBean.class.isInstance(t)),强转下也可以进行某个特殊数据处理了。

4.总结

serializationparcable

文件操作，且用到了反射	单独的内存空间，速度快
会创造大量的读写对象	直接操作内存读写
实现简单	实现复杂，而且读和取的数据要一致
写入的时候，会有字段名，长度等	只是写入数据，节省资源
因为写在文件中，适合持久化数据	不适合持久化数据，可能会变化

如果你们有对3.3的解决方案感觉有更好的处理思路的话，欢迎提出来共同探讨
如果你们觉得文章对你有启示作用，希望你们帮忙点个赞或者关注下，谢谢

总结

以上是生活随笔为你收集整理的Parcelable最强解析的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。