Serializable一个空接口，怎么就能实现序列化？

科技 06-25 来源：喵吉爱科技

理论

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() + "\n" + 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 < primDataSize) {
 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 < objVals.length; 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 < primDataSize) {
 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 < objVals.length; 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;
}