对象序列化的目标：
- 将对的字节序列对象永久的保存到磁盘中。
- 允许在网络上直接传输对象，传输对象的字节序列。
对象序列化：把对象转换为字节序列。
对象反序列化：把字节序列恢复为对象。
如果让某个对象支持序列化机制，必须让它的类是可序列化的（serializable）。
为了让某个类是可序列化的，该类必须实现如下两个接口之一：
- Serializable
- Externalizablie
Externalizable接口继承自 Serializable接口，仅实现Serializable接口的类采用默认的序列化方式 ，而实现Externalizable接口的类完全由自身来控制序列化的行为。
Java 的很多类已经实现了Serializable，该接口是一个标记接口，实现该接口无须实现任何方法，它只是表明该类的实例是可序列化的。
在 JavaEE 中，通常建议：创建的每个JavaBean类都实现Serializable。
关于对象序列化，需要注意的几点：
- 对象的类名、实例变量都会被序列化；方法、类变量（static修饰的成员变量）、transient 修饰的实例变量都不会被序列化。
- 实现 Serializable 接口的类如果需要让某个实例变量不被实例化，则在该实例变量前加 transient 修饰符。
- 要保证序列化对象的引用变量类型也是可序列化的。
- 反序列化对象时必须有序列化对象的 class 文件。
- 当通过文件、网络来读取序列化后的对象时，必须按实际写入的顺序读取。
1、使用对象流来实现序列化
对象序列化的步骤：
1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2） 通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤：
1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2） 通过对象输入流的readObject()方法读取对象。
public class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
/**
* 实现序列化和反序列化
*
*/
public class SerializableTest {
public static void main(String[] args) {
Person person = new Person("小明", 23);
try {
SerializableObject(person);
Person p = (Person) DeserializationObject();
System.out.println(p.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 序列化对象
* @param o
* @throws Exception
*/
public static void SerializableObject(Object o) throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
oos.writeObject(o);
System.out.println("对象序列化成功！");
oos.close();
}
/**
* 反序列化
* @return
* @throws Exception
*/
public static Object DeserializationObject() throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
Object o = ois.readObject();
System.out.println("反序列化成功！");
return o;
}
}
OK！
2、对象引用的序列化
前边例子的Person类的成员变量是String，int型的。
如果某个类的成员变量的类型不是基本类型或String类型，而是另一个引用类型，那么这个引用类必须是可序列化的，否则拥有该类型成员变量的类也是不可序列化的。
public class Teacher implements Serializable {
private String name;
private Person stuName;
}
Teacher类持有一个Person类的引用，只有Person类是可序列化的，Teacher类才是可序列化的。如果Person类不可序列化，则无论Teacher类是否实现了Serializable，Externalizable接口，Teacher类都是不可序列化的。
Java序列化机制采用了一种特殊的序列化算法：
- 所有保存到磁盘中的对象都有一个序列化编号。
- 当试图序列化一个对象时，将先检查该对象是否已经被序列化过，只有该对象从未（在本次虚拟机中）被序列化过，系统才会将该对象转换成字节序列并输出。
- 如果某个对象已经被序列化过，程序将只输出一个序列化编号，而不是再次序列化该对象。
注意：当使用Java序列化机制序列化可变对象时一定要注意，只有第一次调用 writeObject() 方法来输出对象时才会将对象转换成字节序列，并写入到 ObjectOutputStream；在后面程序中即使该对象的实例变量发生了改变，再次调用writeObject() 方法输出该对象时，改变后的实例变量也不会被输出。
3、自定义序列化
有的时候，不希望系统将某一实例变量值进行序列化，或者某个实例变量的类型是不可序列化的。因此就不希望对该实例变量进行递归的序列化，以免引发NotSerializableException 异常。
对某个对象进行序列化时，系统会自动把该对象的所有实例变量依次进行序列化，如果某个实例变量引用到另一个对象，则被引用的对象也会被序列化。如果被引用的对象的实例变量也引用了其他对象，则被引用的对象也会被序列化，这种情况被称为递归序列化。
解决办法一：
在实例变量前面使用 transient 关键字修饰，可以指定Java序列化时无须理会该实例变量。
public class Teacher implements Serializable {
private transient String name;
private Person stuName;
}
transient 关键字只能用于修饰实例变量，不可修饰Java程序中的其他部分。
存在问题：被 transient 修饰的实例变量被完全隔离在序列化机制之外，将导致在反序列化时无法取得该实例变量的值。
解决办法二：
利用Java提供的一种序列化机制，通过这种机制可以让程序控制如何序列化各实例变量，甚至完全不序列化某些实例变量（与使用 transient 关键字的效果相同）。
在序列化和反序列化过程中，需要特殊处理的类应该重写如下的特殊方法，来实现自定义序列化：
private void writeObject(ObjectOutputStream out) throws IOException // 可以自定义序列化机制
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException // 可以自定义反序列化机制
private void readObjectNoData() throws ObjectStreamException // 当序列化流不完整时，该方法可以用来正确地初始化反序列化的对象
注意：writeObject() 方法存储实例变量的顺序应该和readObject() 方法中恢复实例变量的顺序一致，否则将不能正常恢复该Java对象。
解决办法三：
一种更彻底的自定义机制，可以在序列化对象时将该对象替换成其他对象。让序列化类重写以下方法：
任何的访问修饰符 Object writeReplace() throws ObjectStreamException
public class Teacher implements Serializable {
private String name;
private Person stuName;
// 重写 writeReplace 方法，程序在序列化该对象之前，先调用该方法
private Object writeReplace() throws ObjectStreamException {
ArrayList<Object> list = new ArrayList<>();
list.add(name);
list.add(stuName);
return list;
}
}
与之相对应的一个方法：
任何的访问修饰符 Object readResolve() throws ObjectStreamException
该方法在紧接着readObject() 之后被调用，该方法的返回值将会代替原来反序列化的对象，而原来readObject()反序列化的对象将会被立即丢弃。
通常建议：对于 final 类重写 readResolve() 方法不会有任何问题，否则，重写 readResolve() 方法时应该尽量使用 private 修饰符。
反序列化机制在恢复Java对象时无须调用构造器来初始化Java对象，从这个意义上来看，序列化机制可以用来“克隆”对象。
4、另一种自定义序列化机制
这种序列化方式完全由程序员决定存储和恢复对象数据。实现Externalizablie接口，中的两个方法：
void writeExternal(ObjectOutput out) // 实现序列化，调用ObjectOutput的writeObject()方法来保存引用类型的实例变量的值。
调用DataOutput（它是ObjectOutput的父接口）的方法来保存基本类型的实例变量的值。
void readExternal(ObjectInput in) // 实现反序列化，调用ObjectIutput的readObject()方法来恢复引用类型的实例变量的值。
调用DataIutput（它是ObjectIutput的父接口）的方法来恢复基本类型的实例变量的值。
public class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void writeExternal(ObjectOutput out) throws IOException {
//将name实例变量值反转后写入
out.writeObject(new StringBuffer(name).reverse());
out.writeInt(age);
}
public void readExternal(ObjectInput in) throws ClassNotFoundException, IOException {
this.name = ((StringBuffer) in.readObject()).reverse().toString();
this.age = in.readInt();
}
}
由于编程复杂度的原因，大部分时候都是采用实现Serializable接口的方式来实现序列化。
6、版本（serialVersionUID 的作用）
Java序列化机制允许为序列化类提供一个private static final 的 serialVersionUID 值，该类变量的值用于标识该Java类的序列化版本。
这样就能保证即使在某个对象被序列化之后，它所对应的类被修改了，该对象也依然可以被正确的反序列化。避免在反序列化时与序列化版本的兼容性问题。
