对于Java的序列化，我们可以认为是在**数据传输的时候的一套协议或者是一个标准**，因为Java存在自己特定的一个数据结构（class），举个例子 ```kotlin data class User( val name: String, val age: Int ) ``` User是一个对象，我们可以创建一个User对象自己使用，但是实际的场景中，我们往往不会自己单独使用，而是让其他人也用，或者做持久化存储；例如我们之前讲的IPC通信框架，在Server端创建的User，想作为参数传递给客户端使用，所以这个时候就**需要将这个特定的数据结构转化为一组基本的二进制字节数据，这个过程就是一次序列化的过程；而反序列化则是将这组字节数据转换为特定数据结构**。在实际的业务场景中，如果我们使用序列化传输数据，一般就是两种：Serializable 和 Parcelable。 # 1 Serializable原理分析一般我们在使用Serializable的时候，都是实现Serializable接口，例如： ```kotlin data class User( val name: String, val age: Int ):Serializable ``` 按照序列化的定义，只要是实现了Serializable接口，那么就会将特定的数据结构转换为一组二进制字节数据。 ```kotlin public fun serialize(user: User): ByteArray { val bos = ByteArrayOutputStream() val objectInputSystem = ObjectOutputStream(bos) //写数据 objectInputSystem.writeObject(user) return bos.toByteArray() } ``` 对于序列化，**底层的实现就是通过ObjectOutputStream**包装类将User转换为一组二进制字节数据。那么反序列化，将一组二进制数据转换为User类，就需要使用ObjectInputStream读取二进制字节数据。 ```kotlin public fun unSerialize(byteArray: ByteArray): User { val bis = ByteArrayInputStream(byteArray) val objectInputSystem = ObjectInputStream(bis) //读数据 return objectInputSystem.readObject() as User } ``` 所以**ObjectOutputStream和ObjectInputStream可以认为是Java提供的一个序列化工具**，用于将数据拆分和组装。 ## 1.1 与序列化相关的问题在熟悉了序列化的原理之后，针对序列化相关的一些问题，我们需要了解一下，如果伙伴们在准备面试，这块可能会对你有一些帮助。 ```kotlin object SerializeUtils { fun writeObject(t: T,path:String) { val objectOutputStream = ObjectOutputStream(FileOutputStream(path)) //读数据 objectOutputStream.writeObject(t) } fun readObject(path: String): T { val objectInputSystem = ObjectInputStream(FileInputStream(path)) //读数据 return objectInputSystem.readObject() as T } } ``` ### serialVersioUID是什么？首先我们先看一个场景： ```kotlin //先序列化 val user = User("layz4android", 25) SerializeUtils.writeObject(user,"/storage/emulated/0/a.out") //再反序列化 val result = SerializeUtils.readObject("/storage/emulated/0/a.out") Log.e("TAG", "result==>$result") ``` 这是常规的序列化和反序列化 ```java result==>User(name=layz4android, age=25) ``` 那么此时我做什么操作呢？先序列化将数据存储本地，然后修改一下User实体类的数据结构，加了一个sex字段。 ```kotlin data class User( val name: String, val age: Int, val sex:String ) : Serializable ``` 这个时候报了一个错，具体原因就是要反序列化的这组数据与本地现有类的serialVersionUID不一致。因为每个类默认有一个serialVersionUID，如果没有定义那么就会默认生成，因为此时User类已经发生了变化（新加了一个字段），此时这个类就是一个新的类，与本地存储的序列化数组不一致，从而导致序列化失败。 ```java Caused by: java.io.InvalidClassException: com.lay.learn.asm.binder.User; local class incompatible: stream classdesc serialVersionUID = 7638979641876441127, local class serialVersionUID = -6727369848665126143 ``` 所以为了做版本的统一管理，需要引进serialVersionUID这个字段，即便是修改了类中的字段，只要是serialVersionUID一致，在序列化、反序列化的时候就会找到这个类。 ```kotlin data class User( val name: String, val age: Int, ) : Serializable { companion object { val serialVersionUID = 1 } } ``` 即便是新增了一个字段，也不会报错，而是**会将这个参数值为空**。 ```java E/TAG: result==>User(name=layz4android, age=25, sex=null) ``` ### transient关键字还是拿User来说，默认情况下，所有的字段都会参与序列化，那么如果某个字段不想参与序列化，那么有什么手段吗？就是使用transient关键字。 ```kotlin data class User( @Transient val name: String, val age: Int, ) : Serializable { companion object { val serialVersionUID = 1 } } ``` 反序列化后，我们就可以看到，因为name没有参与序列化，所以拿到的值为null ```java E/TAG: result==>User(name=null, age=25) ``` ### 如果一个类中的类成员变量不支持序列化，会发生什么情况？场景如下，UserInner没有实现序列化接口 ```kotlin data class UserInner( val a: Int, val b: String ) ``` ```kotlin data class User( @Transient val name: String, val age: Int, val inner: UserInner ) : Serializable { companion object { val serialVersionUID = 1 } } ``` 那么当进行序列化操作的时候报错，就是因为UserInner不支持序列化。 ```java Caused by: java.io.NotSerializableException: com.lay.learn.asm.binder.UserInner ``` 那么这里我们需要了解，**序列化其实是一次深拷贝的操作**。对于浅拷贝（这里不考虑基本数据类型）只是将引用地址做一次拷贝；深拷贝则是需要重新创建一个对象，并把数据拷贝过去。所以在**序列化的时候，因为还需要做一次本地化存储，所以必定是需要拿到UserInner的数据并存储下来**，所以就需要把UserInner内部的数据序列化，但是UserInner又不支持序列化，所以就会报错。 ### 如果某个类可以序列化，但是其父类不可以序列化，那么这个类可以序列化吗？父类： ```kotlin open class Person( val des: String ) ``` 子类： ```kotlin data class User( @Transient val name: String, val age: Int, ) : Serializable, Person(name) { companion object { val serialVersionUID = 1 } } ``` 此时进行序列化操作的时候，报错：没有可用的构造函数。 ```java Caused by: java.io.InvalidClassException: com.lay.learn.asm.binder.User; no valid constructor at com.lay.learn.asm.SerializeUtils.readObject(Unknown Source:22) ``` 从堆栈信息中，我们看**是在反序列化的时候报错了，说明在序列化存储的时候是没问题的**，那么这里我们就需要看下readObject的源码了 ```java private Object readOrdinaryObject(boolean unshared) throws IOException { //......省略部分代码 Class cl = desc.forClass(); if (cl == String.class || cl == Class.class || cl == ObjectStreamClass.class) { throw new InvalidClassException("invalid class descriptor"); } Object obj; try { obj = desc.isInstantiable() ? desc.newInstance() : null; } catch (Exception ex) { throw (IOException) new InvalidClassException( desc.forClass().getName(), "unable to create instance").initCause(ex); } //......省略部分代码 return obj; } ``` 这里我们先关注下核心代码，我们发现最终反序列化的时候，是通过反射创建一个Object对象，此时我们看直接调用了newInstance()方法。所以这里我们这样想，在**反序列化的时候类似于创建一个子类的过程，此时应该先创建父类，调用父类的构造方法，因为父类没有实现序列化接口，那么父类信息是缺失的，只能调用一个无参构造方法，那么此时父类没有空参构造方法，因此直接报错**。 ```kotlin open class Person( val des: String ){ constructor() : this("") { } } ``` 反之，如果子类没实现序列化接口，而父类实现了，那么这种情况下是可以完成序列化的，因为继承关系，子类就能够获取父类的序列化能力。 ## 1.2 Java处理序列化的过程如果我们想要从源码角度去看序列化的过程，其实只需要关注两个类：ObjectInputStream和ObjectOutputStream。 ObjectOutputStream：用于将特定数据结构拆分成二进制数据，例如类的信息，并本地化存储，那么这个过程如何完成的？ ObjectInputStream：用于将二进制数据合并成想要的数据结构。 ### 1.2.1 数据怎么拆拆数据的核心方法就是ObjectOutputStream的writeObject方法，在这个中传入要拆解的对象，我们以User为例。 ```java public final void writeObject(Object obj) throws IOException { if (enableOverride) { writeObjectOverride(obj); return; } try { writeObject0(obj, false); } catch (IOException ex) { if (depth == 0) { // BEGIN Android-changed: Ignore secondary exceptions during writeObject(). // writeFatalException(ex); try { writeFatalException(ex); } catch (IOException ex2) { // If writing the exception to the output stream causes another exception there // is no need to propagate the second exception or generate a third exception, // both of which might obscure details of the root cause. } // END Android-changed: Ignore secondary exceptions during writeObject(). } throw ex; } } ``` 我们看writeObject0这个方法干了什么？ ```java private void writeObject0(Object obj, boolean unshared) throws IOException { boolean oldMode = bout.setBlockDataMode(false); depth++; try { // ......省略部分代码 // check for replacement object Object orig = obj; Class cl = obj.getClass(); ObjectStreamClass desc; Class repCl; // 核心代码 1 desc = ObjectStreamClass.lookup(cl, true); if (desc.hasWriteReplaceMethod() && (obj = desc.invokeWriteReplace(obj)) != null && (repCl = obj.getClass()) != cl) { cl = repCl; desc = ObjectStreamClass.lookup(cl, true); } // END Android-changed: Make only one call to writeReplace. if (enableReplace) { Object rep = replaceObject(obj); if (rep != obj && rep != null) { cl = rep.getClass(); desc = ObjectStreamClass.lookup(cl, true); } obj = rep; } // if object replaced, run through original checks a second time if (obj != orig) { subs.assign(orig, obj); if (obj == null) { writeNull(); return; } else if (!unshared && (h = handles.lookup(obj)) != -1) { writeHandle(h); return; } } // remaining cases // BEGIN Android-changed: Make Class and ObjectStreamClass replaceable. if (obj instanceof Class) { writeClass((Class) obj, unshared); } else if (obj instanceof ObjectStreamClass) { writeClassDesc((ObjectStreamClass) obj, unshared); // END Android-changed: Make Class and ObjectStreamClass replaceable. } else if (obj instanceof String) { writeString((String) obj, unshared); } else if (cl.isArray()) { writeArray(obj, desc, unshared); } else if (obj instanceof Enum) { writeEnum((Enum) obj, desc, unshared); } else if (obj instanceof Serializable) { // 核心代码 2 writeOrdinaryObject(obj, desc, unshared); } else { if (extendedDebugInfo) { throw new NotSerializableException( cl.getName() + "\n" + debugInfoStack.toString()); } else { throw new NotSerializableException(cl.getName()); } } } finally { depth--; bout.setBlockDataMode(oldMode); } } ``` #### 核心代码1 在这里，我们看到拿到User类的class对象，然后创建了一个ObjectStreamClass类，我们看下这个类是干啥的。 ```java private ObjectStreamClass(final Class cl) { this.cl = cl; // 获取类名 name = cl.getName(); isProxy = Proxy.isProxyClass(cl); isEnum = Enum.class.isAssignableFrom(cl); // 是否实现了serializable接口 serializable = Serializable.class.isAssignableFrom(cl); externalizable = Externalizable.class.isAssignableFrom(cl); Class superCl = cl.getSuperclass(); superDesc = (superCl != null) ? lookup(superCl, false) : null; localDesc = this; if (serializable) { AccessController.doPrivileged(new PrivilegedAction() { public Void run() { // 获取serialVersionUID suid = getDeclaredSUID(cl); try { // 获取全部的字段信息 fields = getSerialFields(cl); computeFieldOffsets(); } catch (InvalidClassException e) { serializeEx = deserializeEx = new ExceptionInfo(e.classname, e.getMessage()); fields = NO_FIELDS; } if (externalizable) { cons = getExternalizableConstructor(cl); } else { cons = getSerializableConstructor(cl); // 看是否有 writeObject readObject readObjectNoData方法 writeObjectMethod = getPrivateMethod(cl, "writeObject", new Class[] { ObjectOutputStream.class }, Void.TYPE); readObjectMethod = getPrivateMethod(cl, "readObject", new Class[] { ObjectInputStream.class }, Void.TYPE); readObjectNoDataMethod = getPrivateMethod( cl, "readObjectNoData", null, Void.TYPE); hasWriteObjectData = (writeObjectMethod != null); } writeReplaceMethod = getInheritableMethod( cl, "writeReplace", null, Object.class); readResolveMethod = getInheritableMethod( cl, "readResolve", null, Object.class); return null; } }); } else { suid = Long.valueOf(0); fields = NO_FIELDS; } try { fieldRefl = getReflector(fields, this); } catch (InvalidClassException ex) { // field mismatches impossible when matching local fields vs. self throw new InternalError(ex); } if (deserializeEx == null) { if (isEnum) { deserializeEx = new ExceptionInfo(name, "enum type"); } else if (cons == null) { deserializeEx = new ExceptionInfo(name, "no valid constructor"); } } for (int i = 0; i < fields.length; i++) { if (fields[i].getField() == null) { defaultSerializeEx = new ExceptionInfo( name, "unmatched serializable field(s) declared"); } } initialized = true; } ``` 在这个类当中，我们看到其实就是拿到User类的class对象之后，获取类中的全部信息，像Class类名、是否实现了serialize接口、serialVersionUID、全部字段信息、是否存在writeObject readObject readObjectNoData方法，总之就是将类的全部信息，封装成了ObjectStreamClass类。 #### 核心代码 2 回到前面的代码中，我们看会做一系列的判断，判断User是什么类型的对象，因为User实现了Serializable接口，所以会走到writeOrdinaryObject方法中，同时将ObjectStreamClass也传了进来。 ```java private void writeOrdinaryObject(Object obj, ObjectStreamClass desc, boolean unshared) throws IOException { if (extendedDebugInfo) { debugInfoStack.push( (depth == 1 ? "root " : "") + "object (class "" + obj.getClass().getName() + "", " + obj.toString() + ")"); } try { desc.checkSerialize(); bout.writeByte(TC_OBJECT); writeClassDesc(desc, false); handles.assign(unshared ? null : obj); if (desc.isExternalizable() && !desc.isProxy()) { writeExternalData((Externalizable) obj); } else { writeSerialData(obj, desc); } } finally { if (extendedDebugInfo) { debugInfoStack.pop(); } } } ``` 首先调用了writeClassDesc方法，在这个方法中，**做的主要事情就是把之前获取的类信息全部全部转换为二进制数据**，从writeNonProxyDesc方法中就可以看到，太深入的我就不介绍了，有精力的伙伴可以深入看一下。 ```java private void writeClassDesc(ObjectStreamClass desc, boolean unshared) throws IOException { int handle; if (desc == null) { writeNull(); } else if (!unshared && (handle = handles.lookup(desc)) != -1) { writeHandle(handle); } else if (desc.isProxy()) { writeProxyDesc(desc, unshared); } else { writeNonProxyDesc(desc, unshared); } } ``` 然后紧接着调用writeSerialData方法，在这个方法中首先会判断这个类中是否存在writeObject、readObject这种方法，这两个方法的时候，我会在Parcelable专题中介绍，如果有的话，那么就会调用invokeWriteObject方法执行这个方法；如果没有，那么就会调用defaultWriteFields方法，将所有的字段数据转换为二进制数据。 ```java private void writeSerialData(Object obj, ObjectStreamClass desc) throws IOException { ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout(); for (int i = 0; i < slots.length; i++) { ObjectStreamClass slotDesc = slots[i].desc; if (slotDesc.hasWriteObjectMethod()) { PutFieldImpl oldPut = curPut; curPut = null; SerialCallbackContext oldContext = curContext; if (extendedDebugInfo) { debugInfoStack.push( "custom writeObject data (class "" + slotDesc.getName() + "")"); } try { curContext = new SerialCallbackContext(obj, slotDesc); bout.setBlockDataMode(true); slotDesc.invokeWriteObject(obj, this); bout.setBlockDataMode(false); bout.writeByte(TC_ENDBLOCKDATA); } finally { curContext.setUsed(); curContext = oldContext; if (extendedDebugInfo) { debugInfoStack.pop(); } } curPut = oldPut; } else { defaultWriteFields(obj, slotDesc); } } } ``` #### 总结所以在writeObject方法中，主要就是干了两件事： **（1）获取User类的全部类信息，包括方法、字段、SUID等等，将其封装在ObjectStreamClass中；** **（2）在拿到全部类信息后，会将全部的类信息以及字段数据转换成二进制数据。** 从源码中我们可以看到，在统计类信息的时候，会检查两个方法是否存在，readObject和writeObject，而且只要实现了这两个方法，那么就不会走defaultWriteFields方法，**所以如果我们添加了这两个方法，就能够修改系统默认序列化的实现方式，从而在readObject和writeObject方法中，对字段数据进行调整**。 ### 1.2.2 数据怎么组装其实这个在之前1.1小节中的一个问题中提到过了，就是通过反射的方式调用无参构造函数创建一个新的对象。因为**在序列化的时候，是将类的全部信息封装在了ObjectStreamClass中，所以反序列化的时候也会获取这些类信息，从而通过反射对所有的字段赋值**。 # 2 Parcelable的出现是为了解决什么问题 Parcelable是Google为了Android单独做的一套序列化协议，因为我们知道，Android为了响应速度，舍弃了JVM，选择了基于寄存器的Dalvik和ART，所以Parcelable的出现目的也是一致的---速度。通过前面我们对于Serializable的理解，首先Serializable的序列化和反序列化是基于IO的，需要做本地化的磁盘存储；还有一个问题就是，**在反序列化的过程中，需要通过反射的形式创建一些新的对象，这些对象也是被存放在堆内存中，会产生内存碎片，其本质还是一个深拷贝，如果发生频繁的反射调用对于性能上是有损耗的**。因此Parcelable的出现就是为了解决这些问题，首当其冲就是速度问题，因为少了磁盘IO的读写，据说速度是Serializable的10倍；因为**Parcelable是基于Binder的，直接在内存中操作数据，减少了磁盘IO操作，但是因为Binder内存的限制，因此不能超过1M**，但是Serializable是没有限制的。除此之外，**Parcelable出现的另一个目的就是为了进程间通信提供数据模型**，像在使用AIDL的时候，如果想要进行数据传递，那么就会使用到Parcelable。