声明：原创文章，转载请注明出处。http://www.jianshu.com/u/e02df63eaa87
1、序列化概念
序列化：把对象转换为字节序列的过程。
反序列化：把字节序列恢复为对象的过程。
对象的序列化主要有两种用途
- 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
- 在网络上传送对象的字节序列。
在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。
2、JDK中的序列化API
2.1 输入输出流
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
对象序列化包括如下步骤：
- 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
- 通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤如下：
- 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
- 通过对象输入流的readObject()方法读取对象。
2.2 Serializable接口
并不是每个对象都能写到输出流。可以写入输出流的对象称为可序列化的。可序列化的对象是java.io.Serializable接口的实例。因此，可序列化对象必须实现Serializable接口。试图存储一个不支持Serializable接口的对象会引起一个NotSerializableException异常。
Serializable接口是一种标记接口。由于它没有任何方法，不需要在类中为实现Serializable接口增加代码。实现这个接口可以启动Java的序列化机制，自动完成存储对象和数组的过程。
只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。
2.3 例子
Person类
public class Person implements Serializable {
private int id;
private int age;
private boolean sex;
private String name;
private String addr;
public Person(int id, int age, boolean sex, String name, String addr) {
this.id = id;
this.age = age;
this.sex = sex;
this.name = name;
this.addr = addr;
}
public Person() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", age=" + age +
", sex=" + sex +
", name='" + name + '\'' +
", addr='" + addr + '\'' +
'}';
}
}
TestSerializable 类
public class TestSerializable {
public static void main(String[] args) {
try {
Person person = new Person(1001, 18, true, "Jack", "BeiJing");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./Person.dat")));
oos.writeObject(person);
oos.close();
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("./Person.dat")));
Person p = (Person) ois.readObject();
System.out.println(p.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
2.4 transient关键字
- 如果一个对象是Serializable实例，但包含了非序列化的成员，那这个对象是不可以被序列化的。
- 如果一个对象序列化时，对于其中的某个对象不希望其被序列化（敏感信息），即使对象中的成员是私有的，通过序列化处理就可以通过文件或拦截网络来访问。
有一种方法可以防止敏感信息被序列化，将类实现为Externalizable，这样，没有任何东西可以自动序列化，并且可以在writeExternal()内部只对所需部分进行显式的序列化。
如果操作的是一个Serializable对象，序列化操作会自动进行。为了能够控制，可以使用transient关键字逐个字段关闭序列化。
例子：
public class Login implements Serializable {
private String username;
private Date date = new Date();
private transient String passuid;
public Login(String username, String passuid) {
this.username = username;
this.passuid = passuid;
}
@Override
public String toString() {
return "Login{" +
"date=" + date +
", username='" + username + '\'' +
", passuid='" + passuid + '\'' +
'}';
}
public static void main(String[] args) throws Exception {
Login login = new Login("Jack", "123456");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./Login.dat")));
oos.writeObject(login);
oos.close();
TimeUnit.SECONDS.sleep(1);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("./Login.dat")));
Login a = (Login) ois.readObject();
System.out.println(a.toString());
}
}
可以看到，其中的date和username域是可见的，而passuid是transient的，所以不会被自动保存到磁盘。另外，自动序列化机制也不会尝试去恢复它，当对象被恢复时，passuid域就会变成null。
由于Externalizable对象在默认情况下不保存任何字段，所以transient关键字只能和Serializable对象一起使用。
2.5 serialVersionUID的作用
serialVersionUID: 字面意思上是序列化的版本号，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量。
private static final long serialVersionUID = 4603642343377807741L;
对于上面Login的例子，增加private String ip;，在对Login.dat进行反序列化：
public class Login implements Serializable {
private String username;
private Date date = new Date();
private transient String passuid;
private String ip;
public Login(String username, String passuid) {
this.username = username;
this.passuid = passuid;
}
@Override
public String toString() {
return "Login{" +
"date=" + date +
", username='" + username + '\'' +
", passuid='" + passuid + '\'' +
'}';
}
public static void main(String[] args) throws Exception {
Login login = new Login("Jack", "123456");
// 序列化
// ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./Login.dat")));
// oos.writeObject(login);
// oos.close();
TimeUnit.SECONDS.sleep(1);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("./Login.dat")));
Login a = (Login) ois.readObject();
System.out.println(a.toString());
}
}
Exception in thread "main" java.io.InvalidClassException: gc.Login; local class incompatible: stream classdesc serialVersionUID = -4069397356839580213, local class serialVersionUID = 3104314666871190943
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:617)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1622)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1517)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1771)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1350)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
...
序列化运行时使用serialVersionUID 版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException异常。
如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计 算该类的默认 serialVersionUID 值。不过，强烈建议所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样 在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。
因此，指定serialVersionUID的值，重新进行序列化：
public class Login implements Serializable {
private static final long serialVersionUID = 4603642343377807741L;
private String username;
private Date date = new Date();
private transient String passuid;
public Login(String username, String passuid) {
this.username = username;
this.passuid = passuid;
}
@Override
public String toString() {
return "Login{" +
"date=" + date +
", username='" + username + '\'' +
", passuid='" + passuid + '\'' +
'}';
}
public static void main(String[] args) throws Exception {
Login login = new Login("Jack", "123456");
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./Login.dat")));
oos.writeObject(login);
oos.close();
}
加入新的字段，再次进行反序列化：
public class Login implements Serializable {
private static final long serialVersionUID = 4603642343377807741L;
private String username;
private Date date = new Date();
private transient String passuid;
private String ip;
public Login(String username, String passuid) {
this.username = username;
this.passuid = passuid;
}
@Override
public String toString() {
return "Login{" +
"date=" + date +
", username='" + username + '\'' +
", passuid='" + passuid + '\'' +
'}';
}
public static void main(String[] args) throws Exception {
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("./Login.dat")));
Login a = (Login) ois.readObject();
System.out.println(a.toString());
}
}
可以看到，Login{date=Thu Mar 09 09:27:35 CST 2017, username='Jack', passuid='null'}，说明反序列化成功了。
显式地定义serialVersionUID有两种用途：
- 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；
- 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。
引用
http://286.iteye.com/blog/2227942
http://www.cnblogs.com/xdp-gacl/p/3777987.html
