Serializable原理

在分析Serializable之前，先来看看ObjectInputStream和ObjectOutputStream这两个流对象。

ObjectOutputStream：将对象转化为流
ObjectInputStream：将流转化为对象
下面举个例子来说明ObjectInputStream和ObjectOutputStream的使用。

public class Phone {

public String name;
public String address;

public Phone() {
    System.out.println("=============1");
}

public Phone(String name, String address) {
    System.out.println("=============2");
    this.name = name;
    this.address = address;
}

}
Phone类是测试类，调用方式如下：

public class MyClass {

public static void main(String[] args) throws IOException, ClassNotFoundException {

    File file = new File("javatest/data/phone.txt");

    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
    Phone phone = new Phone("zhangsan", "beijing");
    objectOutputStream.writeObject(phone);
    objectOutputStream.close();

    System.out.println("========================");

    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
    Object object = objectInputStream.readObject();
    objectInputStream.close();
    if (object instanceof Phone) {
        Phone phone1 = (Phone) object;
        System.out.println(phone1.name);
    }
    System.out.println(object);
}

}
运行后会出现如下错误日志：

Exception in thread “main” java.io.NotSerializableException: com.example.Phone
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at com.example.MyClass.main(MyClass.java:18)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
日志信息提示说Phone没有实现Serializable接口。按照提示将Phone方法做相应的修改：

public class Phone implements Serializable{

public String name;
public String address;

public Phone() {
    System.out.println("=============1");
}

public Phone(String name, String address) {
    System.out.println("=============2");
    this.name = name;
    this.address = address;
}

}
继续执行main()方法，查看日志信息：

=============2

zhangsan
com.example.Phone@4dd8dc3
main()方法的主要流程分为如下几步：
1 创建文件phone.txt
2 创建Phone实例，并初始化，然后通过ObjectOutputStream将Phone的实例写入到phone.txt中
3 通过ObjectInputStream将phone.txt中的内容读出，并构造Object的一个实例，将数据放入Object的实例中。
phone.txt文件中的内容如下：

aced 0005 7372 0011 636f 6d2e 6578 616d
706c 652e 5068 6f6e 6551 4868 16d4 8afd
8702 0002 4c00 0761 6464 7265 7373 7400
124c 6a61 7661 2f6c 616e 672f 5374 7269
6e67 3b4c 0004 6e61 6d65 7100 7e00 0178
7074 0007 6265 696a 696e 6774 0008 7a68
616e 6773 616e
如上是以byte的形式打开，下面来分析一下各个数据代表了什么意思（一下数据均为16进制，省略了ox前缀）：
aced：STREAM_MAGIC，声明使用了序列化协议
0005：STREAM_VERSION，序列化协议版本
73：TC_OBJECT，声明这是一个新的对象
72：TC_CLASSDESC，声明这里开始一个新Class
0011：Class名字的长度
636f 6d2e 6578 616d 706c 652e 5068 6f6e 65：类名，com.example.Phone
51 4868 16d4 8afd 87：SerialVersionUID, 序列化ID，如果没有指定， 则会由算法随机生成一个8byte的ID。
02：标记号，该值声明该对象支持序列化
0002：该类所包含的域个数
4c：L
00 07：域名字的长度
61 6464 7265 7373：address
74：TC_STRING，代表一个new String，用String来引用对象
00 12：长度
4c：L
6a61 7661 2f6c 616e 672f 5374 7269 6e67 3b4c：java/lang/String;L
0004：域名字的长度
6e61 6d65：name
7100 7e00 01：待确认
78：TC_ENDBLOCKDATA对象块结束的标志
70：没有超类
74：TC_STRING
0007：address字段值的长度
6265 696a 696e 67：address字段的值beijing
74：TC_STRING
0008：name字段值的长度
7a68 616e 6773 616e : name字段的值zhangsan
文件中的内容相当丰富，仅仅凭这些内容，已经可以完整的复原Phone实例存储前的状态。
其实，如上过程，就是Java 序列化和反序列化的一个简单的实现。
Serializable也能够实现自定义序列化过程。
重新定义Phone类如下：

public class Phone implements Serializable {

transient public String name;
public String address;

public Phone() {
    System.out.println("=============1");
}

public Phone(String name, String address) {
    System.out.println("=============2");
    this.name = name;
    this.address = address;
}

private void writeObject(ObjectOutputStream out) throws IOException {
    out.defaultWriteObject();
    out.writeBytes(name);
    System.out.println("=========write");
}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();
    byte[] bytes = new byte[50];
    in.read(bytes);
    name = new String(bytes).trim();
    System.out.println("=========read");
}

}
将name属性添加了transient修饰，添加了两个方法writeObject()和readObject()。运行main()方法，日志信息如下：

=============2
=========write

=========read
zhangsan
com.example.Phone@58372a00
关于Serializable的使用，有几点需要说明：
1 Serializable只是一个接口，本身没有任何实现
2 对象的反序列化并没有调用对象的任何构造方法
3 serialVersionUID是用于记录文件版本信息的，最好能够自定义。否则，系统会自动生成一个serialVersionUID，文件或者对象的任何改变，都会改变serialVersionUID，导致反序列化的失败，如果自定义就没有这个问题。
4 如果某个属性不想实现序列化，可以采用transient修饰
5 Serializable的系统实现是采用ObjectInputStream和ObjectOutputStream实现的，这也是为什么调用ObjectInputStream和ObjectOutputStream时，需要对应的类实现Serializable接口。