这两天有个同事在使用泛型的过程中，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_OBJECT
writeClassDesc(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>() {
@Override
public BaseBean createFromParcel(Parcel source) {
return new BaseBean(source);
}
@Override
public BaseBean[] newArray(int size) {
return new BaseBean[size];
}
};
很明显，在这里返回的BaseBean的对象，当你用ChildBean去接收的时候肯定会出现类型转换错误啦，如果还觉得想用ChildBean来接收的话(前提是有强迫症),可以重写createFromParcel方法
@Override
public 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{
...
@Override
public String getName(){
return "WelliJohn";
}
...
}
当用到了传值的时候，ChildBean再自身实现了Parcelable接口，这样代码就完美了。这样如果真的在公共界面有个特殊的类型的话，判断下T的类型(ChildBean.class.isInstance(t)),强转下也可以进行某个特殊数据处理了。
4.总结
| serialization | parcable |
|---|---|
| 文件操作，且用到了反射 | 单独的内存空间，速度快 |
| 会创造大量的读写对象 | 直接操作内存读写 |
| 实现简单 | 实现复杂，而且读和取的数据要一致 |
| 写入的时候，会有字段名，长度等 | 只是写入数据，节省资源 |
| 因为写在文件中，适合持久化数据 | 不适合持久化数据，可能会变化 |
如果你们有对3.3的解决方案感觉有更好的处理思路的话，欢迎提出来共同探讨
如果你们觉得文章对你有启示作用，希望你们帮忙点个赞或者关注下，谢谢
