序列化就是让对象变成字节序列，进行传输和保存；相反地，把字节序列变对象，叫反序列化。
如下：一个类实现了Serializable接口，并写了serialVersionUID，就可正常进行序列化。
public class Source implements Serializable {
private static final long serialVersionUID = 6067841943119850745L;
private String name;
private String type;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
序列化：调用ObjectOutputStream的writeObject方法接口
//要序列化的对象
Source source = new Source();
source.setName("gallery");
source.setType("png");
//保存本地文件路径
File file = new File("sdcard/source");
//创建ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
//调用writeObject (writexxx)
oos.writeObject(source);
//关闭
oos.close();
反序列化：调用ObjectInputStream 的readObject方法接口
//创建ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
//调用readObject
Source source1 = (Source) ois.readObject();
//关闭
ois.close();
序列化和反序列化的过程比较简单，Serializable的作用只是一个标记；writeObject方法中会判断是否是是 instanceof Serializable
writeObject(Object obj) -> writeObject0(Object obj, boolean unshared)
private void writeObject0(Object obj, boolean unshared)
throws IOException
{
……
} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);
} else {
……
}
} f
}
writeOrdinaryObject 开始写入
private void writeOrdinaryObject(Object obj,
ObjectStreamClass desc,
boolean unshared)
throws IOException
{
……
desc.checkSerialize();
//开始写入的标记TC_OBJECT
bout.writeByte(TC_OBJECT);
//写入类的描述符
writeClassDesc(desc, false);
……
//写入需要序列化的数据
writeSerialData(obj, desc);
……
}
}
写入类的描述符
writeClassDesc 正常调用到（非动态代理） writeNonProxyDesc
private void writeClassDesc(ObjectStreamClass desc, boolean unshared)
throws IOException
{
int handle;
if (desc == null) {
writeNull();
} ……
else {
writeNonProxyDesc(desc, unshared);
}
}
writeNonProxyDesc
private void writeNonProxyDesc(ObjectStreamClass desc, boolean unshared)
throws IOException
{
//标记开始写入类描述
bout.writeByte(TC_CLASSDESC);
……
//真正写入类描述
desc.writeNonProxy(this);
……
//标记结束写入类描述
bout.writeByte(TC_ENDBLOCKDATA);
……
//循环写入父类的描述，知道父类为null
writeClassDesc(desc.getSuperDesc(), false);
}
writeNonProxy中写入了类名，serialVersionUID，标记，字段类型、字段名等信息
serialVersionUID 是唯一识别码，序列化前后发送变化，则反序列化会失败，如果用户用户赋值，则会调用computeDefaultSUID方法计算，计算过程比较复杂，会被字段方法等影响，如当序列化前后，类的字段方式变化，则自动计算的suid会不一样，导致序列化失败，因此serialVersionUID 需要写上。
void writeNonProxy(ObjectOutputStream out) throws IOException {
out.writeUTF(name);
out.writeLong(getSerialVersionUID());
byte flags = 0;
……
flags |= ObjectStreamConstants.SC_SERIALIZABLE;
……
out.writeByte(flags);
out.writeShort(fields.length);
for (int i = 0; i < fields.length; i++) {
ObjectStreamField f = fields[i];
out.writeByte(f.getTypeCode());
out.writeUTF(f.getName());
if (!f.isPrimitive()) {
out.writeTypeString(f.getTypeString());
}
}
}
写入需要序列化的数据
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()) {
//如果这个类自己写了writeObject 方法，就走这里
……
} else {
//这个类没写writeObject 方法，调用默认
defaultWriteFields(obj, slotDesc);
}
}
}
defaultWriteFields 里面区分了基本数据类型和非基本数据类型，另外static和transient(瞬时状态)修饰的字段不可序列化
private void defaultWriteFields(Object obj, ObjectStreamClass desc)
throws IOException
{
……
//获取对象obj的可序列化的基本类型(byte、short、int、long、float、double...)字段值，并将其编组为从偏移量0开始的字节数组buf。
desc.getPrimFieldValues(obj, primVals);
bout.write(primVals, 0, primDataSize, false);
//获取所有可序列化的字段，其中调到getDefaultSerialFields，里面过滤了static和transient修饰的字段(Modifier.STATIC | Modifier.TRANSIENT)，也就是static和transient修饰的字段不可序列化
ObjectStreamField[] fields = desc.getFields(false);
//返回所表示类的非基本数据类型可序列化字段数组。非基本类型的字段需要再次走writeObject0方法，进一步序列化
//这个非基本数据类型的字段也必须是可序列化的，也即继承serializable，否则，会导致此类不能序列化
Object[] objVals = new Object[desc.getNumObjFields()];
//获取对象obj的可序列化的对象字段值，并将它们存储在从偏移量0开始的数组vals中。
desc.getObjFieldValues(obj, objVals);
for (int i = 0; i < objVals.length; i++) {
……
try {
writeObject0(objVals[i],
fields[numPrimFields + i].isUnshared());
} finally {
……
}
}
}
自定义序列化过程
上面分析的过程都是使用了默认的序列化，其实在实现了接口的序列化时，可以有一些自定义的方法
查看ObjectStreamClass中的字段，发现有五个可以自动定义的方法
/** class-defined writeObject method, or null if none */
private Method writeObjectMethod;
/** class-defined readObject method, or null if none */
private Method readObjectMethod;
/** class-defined readObjectNoData method, or null if none */
private Method readObjectNoDataMethod;
/** class-defined writeReplace method, or null if none */
private Method writeReplaceMethod;
/** class-defined readResolve method, or null if none */
private Method readResolveMethod;
通过查看其反射获取，可以定义出
//getPrivateMethod 是获取私有非静态方法
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);
//getInheritableMethod 获取非静态，非抽象，共有和保护类方法可以从父类中查找，私有只能从本类中查找
writeReplaceMethod = getInheritableMethod(cl, "writeReplace", null, Object.class);
readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);
结合源码：
序列化时：先调用writeReplace，再调用writeObject
反序列化时：先调用readObject，为空时调用readObjectNoData，最后调用readResolve
- 如果一个序列化类中含有writeReplace()方法，那么实际序列化的对象将是作为writeReplace方法返回值的对象
- 如果一个序列化类中含有writeObject()方法，那么具体序列化的过程就使用writeObject()里的。
- 如果一个序列化类中含有readObject()方法，那么具体反序列化的过程就使用readObject()里的。
- 如果一个序列化类中含有readResolve()方法，那么实际反序列化的最终结果就是readResolve返回值的值。
- 如果一个序列化类中含有readObjectNoData()方法，那么当获取到的序列化结果为空时，就使用该方法返回的值。
private Object writeReplace() {
}
private void writeObject(ObjectOutputStream oos) throws IOException {
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
}
private void readObjectNoData() {
}
private Object readResolve() {
}
可外化接口 Externalizable
public interface Externalizable extends java.io.Serializable {
// 序列化
void writeExternal(ObjectOutput out) throws IOException;
//反序列化
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
Externalizable是继承了Serializable的
参考: https://www.cnblogs.com/dgwblog/p/11710814.html