对于Java的序列化，我们可以认为是在数据传输的时候的一套协议或者是一个标准，因为Java存在自己特定的一个数据结构（class），举个例子
data class User(
val name: String,
val age: Int
)
User是一个对象，我们可以创建一个User对象自己使用，但是实际的场景中，我们往往不会自己单独使用，而是让其他人也用，或者做持久化存储；例如我们之前讲的IPC通信框架，在Server端创建的User，想作为参数传递给客户端使用，所以这个时候就需要将这个特定的数据结构转化为一组基本的二进制字节数据，这个过程就是一次序列化的过程；而反序列化则是将这组字节数据转换为特定数据结构。
在实际的业务场景中，如果我们使用序列化传输数据，一般就是两种：Serializable 和 Parcelable。
1 Serializable原理分析
一般我们在使用Serializable的时候，都是实现Serializable接口，例如：
data class User(
val name: String,
val age: Int
):Serializable
按照序列化的定义，只要是实现了Serializable接口，那么就会将特定的数据结构转换为一组二进制字节数据。
public fun serialize(user: User): ByteArray {
val bos = ByteArrayOutputStream()
val objectInputSystem = ObjectOutputStream(bos)
//写数据
objectInputSystem.writeObject(user)
return bos.toByteArray()
}
对于序列化，底层的实现就是通过ObjectOutputStream包装类将User转换为一组二进制字节数据。那么反序列化，将一组二进制数据转换为User类，就需要使用ObjectInputStream读取二进制字节数据。
public fun unSerialize(byteArray: ByteArray): User {
val bis = ByteArrayInputStream(byteArray)
val objectInputSystem = ObjectInputStream(bis)
//读数据
return objectInputSystem.readObject() as User
}
所以ObjectOutputStream和ObjectInputStream可以认为是Java提供的一个序列化工具，用于将数据拆分和组装。
1.1 与序列化相关的问题
在熟悉了序列化的原理之后，针对序列化相关的一些问题，我们需要了解一下，如果伙伴们在准备面试，这块可能会对你有一些帮助。
object SerializeUtils {
fun <T> writeObject(t: T,path:String) {
val objectOutputStream = ObjectOutputStream(FileOutputStream(path))
//读数据
objectOutputStream.writeObject(t)
}
fun <T> readObject(path: String): T {
val objectInputSystem = ObjectInputStream(FileInputStream(path))
//读数据
return objectInputSystem.readObject() as T
}
}
serialVersioUID是什么？
首先我们先看一个场景：
//先序列化
val user = User("layz4android", 25)
SerializeUtils.writeObject(user,"/storage/emulated/0/a.out")
//再反序列化
val result = SerializeUtils.readObject<User>("/storage/emulated/0/a.out")
Log.e("TAG", "result==>$result")
这是常规的序列化和反序列化
result==>User(name=layz4android, age=25)
那么此时我做什么操作呢？先序列化将数据存储本地，然后修改一下User实体类的数据结构，加了一个sex字段。
data class User(
val name: String,
val age: Int,
val sex:String
) : Serializable
这个时候报了一个错，具体原因就是要反序列化的这组数据与本地现有类的serialVersionUID不一致。因为每个类默认有一个serialVersionUID，如果没有定义那么就会默认生成，因为此时User类已经发生了变化（新加了一个字段），此时这个类就是一个新的类，与本地存储的序列化数组不一致，从而导致序列化失败。
Caused by: java.io.InvalidClassException: com.lay.learn.asm.binder.User; local class incompatible: stream classdesc serialVersionUID = 7638979641876441127, local class serialVersionUID = -6727369848665126143
所以为了做版本的统一管理，需要引进serialVersionUID这个字段，即便是修改了类中的字段，只要是serialVersionUID一致，在序列化、反序列化的时候就会找到这个类。
data class User(
val name: String,
val age: Int,
) : Serializable {
companion object {
val serialVersionUID = 1
}
}
即便是新增了一个字段，也不会报错，而是会将这个参数值为空。
E/TAG: result==>User(name=layz4android, age=25, sex=null)
transient关键字
还是拿User来说，默认情况下，所有的字段都会参与序列化，那么如果某个字段不想参与序列化，那么有什么手段吗？就是使用transient关键字。
data class User(
@Transient
val name: String,
val age: Int,
) : Serializable {
companion object {
val serialVersionUID = 1
}
}
反序列化后，我们就可以看到，因为name没有参与序列化，所以拿到的值为null
E/TAG: result==>User(name=null, age=25)
如果一个类中的类成员变量不支持序列化，会发生什么情况？
场景如下，UserInner没有实现序列化接口
data class UserInner(
val a: Int,
val b: String
)
data class User(
@Transient
val name: String,
val age: Int,
val inner: UserInner
) : Serializable {
companion object {
val serialVersionUID = 1
}
}
那么当进行序列化操作的时候报错，就是因为UserInner不支持序列化。
Caused by: java.io.NotSerializableException: com.lay.learn.asm.binder.UserInner
那么这里我们需要了解，序列化其实是一次深拷贝的操作。对于浅拷贝（这里不考虑基本数据类型）只是将引用地址做一次拷贝；深拷贝则是需要重新创建一个对象，并把数据拷贝过去。
所以在序列化的时候，因为还需要做一次本地化存储，所以必定是需要拿到UserInner的数据并存储下来，所以就需要把UserInner内部的数据序列化，但是UserInner又不支持序列化，所以就会报错。
如果某个类可以序列化，但是其父类不可以序列化，那么这个类可以序列化吗？
父类：
open class Person(
val des: String
)
子类：
data class User(
@Transient
val name: String,
val age: Int,
) : Serializable, Person(name) {
companion object {
val serialVersionUID = 1
}
}
此时进行序列化操作的时候，报错：没有可用的构造函数。
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的源码了
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()方法。
所以这里我们这样想，在反序列化的时候类似于创建一个子类的过程，此时应该先创建父类，调用父类的构造方法，因为父类没有实现序列化接口，那么父类信息是缺失的，只能调用一个无参构造方法，那么此时父类没有空参构造方法，因此直接报错。
open class Person(
val des: String
){
constructor() : this("") {
}
}
反之，如果子类没实现序列化接口，而父类实现了，那么这种情况下是可以完成序列化的，因为继承关系，子类就能够获取父类的序列化能力。
1.2 Java处理序列化的过程
如果我们想要从源码角度去看序列化的过程，其实只需要关注两个类：ObjectInputStream和ObjectOutputStream。
ObjectOutputStream：用于将特定数据结构拆分成二进制数据，例如类的信息，并本地化存储，那么这个过程如何完成的？
ObjectInputStream：用于将二进制数据合并成想要的数据结构。
1.2.1 数据怎么拆
拆数据的核心方法就是ObjectOutputStream的writeObject方法，在这个中传入要拆解的对象，我们以User为例。
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这个方法干了什么？
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类，我们看下这个类是干啥的。
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<Void>() {
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也传了进来。
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方法中就可以看到，太深入的我就不介绍了，有精力的伙伴可以深入看一下。
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方法，将所有的字段数据转换为二进制数据。
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。
