理论
Java 序列化是 JDK 1.1 时引入的开创性的特性，用于将 Java 物件转换为字节阵列，便于储存或传输。反之，也可以将字节阵列转换回 Java 物件原有的状态。序列化的思想是“冻结”物件状态，然后写到磁盘或者在网络中传输；反序列化的思想是“解冻”物件状态，重新获得可用的 Java 物件。
我们来看看序列化 Serializbale 界面的定义：
public interface Serializable {
}
居然是一个空界面！那怎么保证实现类物件被序列化和反序列化的？
实践
建立一个类，用于序列化和反序列化。class Toutiao {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
此时并未实现序列化界面。在建立一个测试类。
public class TestSerializable {
public static void main(String[] args) {
Toutiao toutiao = new Toutiao();
toutiao.setName("miaoji");
toutiao.setAge(18);
System.out.println(toutiao);
// 将物件写到档案
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:" + File.separator + "miaoji"));) {
oos.writeObject(toutiao);
} catch (IOException e) {
e.printStackTrace();
}
// 从档案中读出物件
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("F:" + File.separator + "miaoji")));){
Toutiao toutiao1 = (Toutiao) ois.readObject();
System.out.println(toutiao1);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
将物件写入到档案中，这其实是一种序列化过程，而从档案中读取资料，这实际就是一种反序列化过程。启动程式执行，结果：
很明显，丢掷异常。顺着堆叠资讯，点开来看ObjectOutputStream 的 writeObject0() 方法。其中部分源代码：
// remaining cases
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) {
writeOrdinaryObject(obj, desc, unshared);
} else {
if (extendedDebugInfo) {
throw new NotSerializableException(
cl.getName() + " " + debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}
可以看到，ObjectOutputStream 在序列化的时候，会判断被序列化的物件是哪一种型别，字串？阵列？列举？还是 Serializable，如果全都不是的话，丢掷 NotSerializableException。接下来，让Toutiao类实现序列化界面。
class Toutiao implements Serializable{
private static final long serialVersionUID = 7440801442918341436L;
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
debug程式，可以具体看到ObjectOutputStream在序列化过程中会依次呼叫：writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→defaultWriteFields()。
private void defaultWriteFields(Object obj, ObjectStreamClass desc)
throws IOException
{
Class> cl = desc.forClass();
desc.checkDefaultSerialize();
int primDataSize = desc.getPrimDataSize();
if (primVals == null || primVals.length primVals = new byte[primDataSize];
}
desc.getPrimFieldValues(obj, primVals);
bout.write(primVals, 0, primDataSize, false);
ObjectStreamField[] fields = desc.getFields(false);
Object[] objVals = new Object[desc.getNumObjFields()];
int numPrimFields = fields.length - objVals.length;
desc.getObjFieldValues(obj, objVals);
for (int i = 0; i try {
writeObject0(objVals[i],
fields[numPrimFields + i].isUnshared());
} finally {
if (extendedDebugInfo) {
debugInfoStack.pop();
}
}
}
}
ObjectOutputStream的反序列化过程：readObject()→readObject0()→readOrdinaryObject()→readSerialData()→defaultReadFields()。
private void defaultReadFields(Object obj, ObjectStreamClass desc)
throws IOException
{
Class> cl = desc.forClass();
int primDataSize = desc.getPrimDataSize();
if (primVals == null || primVals.length primVals = new byte[primDataSize];
}
bin.readFully(primVals, 0, primDataSize, false);
if (obj != null) {
desc.setPrimFieldValues(obj, primVals);
}
int objHandle = passHandle;
ObjectStreamField[] fields = desc.getFields(false);
Object[] objVals = new Object[desc.getNumObjFields()];
int numPrimFields = fields.length - objVals.length;
for (int i = 0; i ObjectStreamField f = fields[numPrimFields + i];
objVals[i] = readObject0(f.isUnshared());
if (f.getField() != null) {
handles.markDependency(objHandle, passHandle);
}
}
if (obj != null) {
desc.setObjFieldValues(obj, objVals);
}
passHandle = objHandle;
}
看到这里，明白了，Serializable 界面之所以定义为空，是因为它只起到了一个标识的作用，告诉程式实现了它的物件是可以被序列化的，但真正序列化和反序列化的操作并不需要它来完成。
注意事项：static 和 transient 修饰的字段是不会被序列化的。
END
