简介
对于一个存在于Java虚拟机中的对象来说，其内部的状态只保持在内存中。JVM停止之后，这些状态就丢失了。在很多情况下，对象的内部状态是需要被持久化保存。对象序列化机制（object serialization）是Java语言内建的一种对象持久化方式，可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。
除了可以很简单的实现持久化之外，当使用远程方法（RPC）调用，或在网络中传递对象时，都会用到对象序列化。
JDK内置序列化
由于Java提供了良好的默认支持，实现基本的对象序列化是件比较简单的事。待序列化的Java类只需要实现java.io.Serializable接口即可。Serializable仅是一个标记接口，并不包含任何需要实现的具体方法。实现该接口只是为了声明该Java类的对象是可以被序列化的。实际的序列化和反序列化工作是通过java.io.ObjectOuputStream和java.io.ObjectInputStream来完成的。ObjectOutputStream的writeObject方法可以把一个Java对象写入到流中，ObjectInputStream的readObject方法可以从流中读取一个Java对象。
序列化示例
package com.bytebeats.codelab.serialization.jdk;
import com.bytebeats.codelab.serialization.model.User;
import com.bytebeats.codelab.serialization.util.IoUtils;
import java.io.*;
import java.util.Arrays;
public class JdkSerializationDemo {
public static void main(String[] args) {
User user = new User();
user.setId(1L);
user.setName("Ricky");
user.setPassword("root");
user.setAge(28);
user.setHobbies(Arrays.asList("Music", "Basketball"));
System.out.println(user);
File objectFile = new File("user.bin");
//Write Obj to File
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(objectFile));
oos.writeObject(user);
} catch (IOException e) {
e.printStackTrace();
} finally {
IoUtils.closeQuietly(oos);
}
//Read Obj from File
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(objectFile));
User newUser = (User) ois.readObject();
System.out.println(newUser);
} catch (Exception e) {
e.printStackTrace();
} finally {
IoUtils.closeQuietly(ois);
}
}
}
上面的代码给出了典型的把Java对象序列化之后保存到磁盘上，以及从磁盘上读取的基本方式。 其中，User类只是声明了实现Serializable接口，代码如下：
package com.bytebeats.codelab.serialization.model;
import java.io.Serializable;
import java.util.List;
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private Long id;
private String name;
private String password;
private int age;
private List<String> hobbies;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
}
在Java默认的序列化实现中，Java对象中的非静态和非瞬时成员变量都会被包括进来，而与成员变量的可见性声明没有关系。这可能会导致某些不应该出现的成员变量被包含在序列化之后的字节数组中，比如密码等隐私信息。由于Java对象序列化之后的格式是固定的，其它人可以很容易的从中分析出其中的各种信息。对于这种情况，一种解决办法是把成员变量声明为瞬时的，即使用transient关键词。
例如，不想序列化User的password属性，可以在 password变量前加上 transient 关键字，如下：
import java.io.Serializable;
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private Long id;
private String name;
private int age;
private transient String password;
......
}
自定义对象序列化策略
基本的对象序列化机制让开发人员可以在包含哪些域上进行定制。如果想对序列化的过程进行更加细粒度的控制，就需要在类中添加writeObject和对应的 readObject方法。这两个方法属于前面提到的序列化机制的隐含契约的一部分。在通过ObjectOutputStream的 writeObject方法写入对象的时候，如果这个对象的类中定义了writeObject方法，就会调用该方法，并把当前 ObjectOutputStream对象作为参数传递进去。writeObject方法中一般会包含自定义的序列化逻辑，比如在写入之前修改域的值，或是写入额外的数据等。对于writeObject中添加的逻辑，在对应的readObject中都需要反转过来，与之对应。
在添加自己的逻辑之前，推荐的做法是先调用Java的默认实现。在writeObject方法中通过ObjectOutputStream的defaultWriteObject来完成，在readObject方法则通过ObjectInputStream的defaultReadObjec来实现。下面的代码在对象的序列化流中写入了一个额外的字符串。
public class Order implements Serializable {
private static final long serialVersionUID = -677602304925255450L;
private String name;
private String address;
private void writeObject(ObjectOutputStream output) throws IOException {
output.defaultWriteObject();
output.writeUTF("Hello World");
}
private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException {
input.defaultReadObject();
String value = input.readUTF();
System.out.println(value);
}
}
接下来，我们看看 java.util.ArrayList中序列化是怎么实现，ArrayList相关代码如下：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
版本更新
把一个Java对象序列化之后，所得到的字节数组一般会保存在磁盘或数据库之中。在保存完成之后，有可能原来的Java类有了更新，比如添加了额外的域。这个时候从兼容性的角度出发，要求仍然能够读取旧版本的序列化数据。在读取的过程中，当ObjectInputStream发现一个对象的定义的时候，会尝试在当前JVM中查找其Java类定义。这个查找过程不能仅根据Java类的全名来判断，因为当前JVM中可能存在名称相同，但是含义完全不同的Java 类。这个对应关系是通过一个全局惟一标识符serialVersionUID来实现的。通过在实现了Serializable接口的类中定义该域，就声明了该Java类的一个惟一的序列化版本号。JVM会比对从字节数组中得出的类的版本号，与JVM中查找到的类的版本号是否一致，来决定两个类是否是兼容的。对于开发人员来说，需要记得的就是在实现了Serializable接口的类中定义这样的一个域，并在版本更新过程中保持该值不变。当然，如果不希望维持这种向后兼容性，换一个版本号即可。在Intellij IDEA中，如果Java类实现了Serializable接口，Intellij IDEA会提示并帮你生成这个serialVersionUID。
在类版本更新的过程中，某些操作会破坏向后兼容性。如果希望维持这种向后兼容性，就需要格外的注意。一般来说，在新的版本中添加东西不会产生什么问题，而去掉一些域则是不行的。
小结
对Java默认序列化做一个总结，如下：
- 在Java中，只要一个类实现了java.io.Serializable接口，那么它就可以被序列化。
- 通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化。
- 虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（即private static final long serialVersionUID）
- 对象序列化时非静态和非瞬时成员变量都会被包括进来，并不保存静态变量。
- 如果某个类的实例需要被序列化，那么该类包含的其它类也需要实现Serializable 接口，例如
public class Order { private Address address; }，如果Order要序列化，Address 也需要Serializable 接口。 -
transient关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient变量的值被设为初始值。 - 如果想自定义序列化策略，可以在类中添加writeObject和 readObject方法。
参考资料
http://www.infoq.com/cn/articles/cf-java-object-serialization-rmi
