首先明确一点：默认的序列化方法速度很慢，因为需要对整个对象和他的类都进行保存，因此我们建议自定义序列化格式。
ObjectInputStream和ObjectOutputStream
| 用途 | ObjectInputStream | ObjectOutputStream |
| 整数 | readInt() | writeInt(int) |
| 浮点数 | readDouble() | writeDouble(double) |
| 字符串 | readUTF() | writeUTF(String) |
| 字节数组 | read(byte[] buf, int off,int length) | write(byte[]) |
| 对象 | readObject() | writeObject(Object) |
哪些数据不会被序列化
- 被标记为 transient 的域。
- 静态变量。
查看某个类的SerialVersionUID
如果类A实现了Serializable接口，则可以使用Java 提供的serialver命令： serialver A 。
SerialVersionUID变量的作用
场景：你在公司开发一个类（记为LogManager，用来管理日志，拥有变量Date date,String description，我们使用序列化保存日志信息），并且已经上线使用（已经积累了一些数据），随着时间的推移，你发现你这个类设计的不够完善，因此你需要添加一个实例变量 int errorID，那么你如果按照一般反序列化方法（readObject），则会抛出：InvalidClassException。那么怎么能够成功将原始的数据转换成新版本的LogManager对象呢？
解决：
- 使用 Java 提供的serialver命令： serialver LogManager 计算出原始LogManager的 serialVersionUID（比如为123L）。
- 在新版本的LogManager中添加： static final long serialVersionUID = 123L；
目的：保持不同版本类的序列化的兼容性。
序列化类A（类A继承自类B），但是类B不可序列化，怎么办？
默认情况：
- 先将类A的实例变量全部还原。
- 因为类A继承类B，因此类A的对象也会有类B的实例变量，对于类B的实例变量，调用类B的默认无参构造函数初始化类B的实例变量。（一定要定义超类无参构造函数，不然会抛 no valid constructor）
解决：自定义readObject和writeObject。
对序列化的数据加密
问题：我们知道，序列化主要用于数据传输，但是序列化的数据是可以反序列化的，因此黑客可以直接把你的数据截下来（比如你的序列化文件为data.txt，用WinHeX打开后，基本就能看到所涉及的类和你传输的数据）。那么怎么样能够加密序列化的数据呢？
解决：通过自定义的序列化方法（在要序列化的对象中实现readObject和writeObject方法）。
- private void writeObject(ObjectOutputStream os)throws IOException // 你如果重写时必须是private的。
- private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException //你如果重写时必须是private的
import java.io.*;
public class Serialize05
{
public static void main(String[] args) throws Exception{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
out.writeObject(new Person("admin","abc123"));
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
Person person = (Person)in.readObject();
System.out.println(person);
}
}
class Person implements Serializable
{
String name;
String password;
public Person(String name,String password)
{
this.name = name;
this.password = password;
}
private void writeObject(ObjectOutputStream os)throws IOException
{
os.writeUTF(name);
byte[] pass = password.getBytes("UTF-8");
for(int i=0;i<pass.length;i++)
{
pass[i] = (byte)(pass[i] ^ 32); //对密码加密
}
os.write(pass);
}
private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException
{
name = is.readUTF();
byte[] pass = new byte[1024];
int size = is.read(pass,0,1024);
for(int i=0;i<pass.length;i++)
{
pass[i] = (byte)(pass[i] ^ 32); //对密码解密
}
String password = new String(pass,0,size,"UTF-8");
this.password = password;
}
public String toString()
{
return "name="+name+",password="+password;
}
}
利用序列化实现深层复制
/*
用序列化实现深层复制
*/
import java.io.*;
public class Serialize09
{
public static void main(String[] args) throws Exception{
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
Person f1 = new Person("f1",null);
Person p1 = new Person("u1",f1);
out.writeObject(p1);
byte[] b = bout.toByteArray();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(b));
Person p2 = (Person)in.readObject();
p2.friend.name = "f2";
System.out.println(p1.friend.name); //输出：f1.虽然p2的朋友名字改变了，但是p1的朋友没改。 }
}
class Person implements Serializable
{
String name;
Person friend;
public Person(String name,Person friend)
{
this.name = name;
this.friend = friend;
}
}
序列化包含别人开发过的不可序列化的类
问题：如果你想要开发一个 House 类，此时别人已经开发好的 Furniture 类（Furniture 类中有实例变量int size，没有类Furniture的源代码，只有class文件，且类Furniture不是可序列化的）。因为House HAS-A Furniture，因此需要组合，因此在House类中需要声明一个Furniture的实例变量，但是Furniture并不能实例化，如果按照一般的方法，则会抛“NoSerializableException”。
解决：
- 将Furniture实例变量设为transient。
- 在House类中实现readObject和writeObject方法。
实现方法：
- private void writeObject(ObjectOutputStream os)throws IOException
- private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException
import java.io.*;
public class Serialize03
{
public static void main(String[] args) throws Exception {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
out.writeObject(new A(new B(10),100));
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
A a = (A)in.readObject();
System.out.println(a); //输出：b=10,a=100
}
}
class B //别人已经开发好的类，且假设看不到B的源代码
{
int bb;
public B(int bb)
{
this.bb = bb;
}
}
class A implements Serializable
{
transient B b;
int a;
public A(B b,int a)
{
this.b = b;
this.a = a;
}
public String toString()
{
return "b="+b.bb+",a="+a;
}
private void writeObject(ObjectOutputStream os)throws IOException //手工序列化B b
{
os.defaultWriteObject();
os.writeInt(b.bb);
}
private void readObject(ObjectInputStream is)throws IOException,ClassNotFoundException
{
is.defaultReadObject();
b = new B(is.readInt());
}
}
writeReplace和readResolve方法
如果有一个类A、类AProxy，如果想要实现以下任务：当 writeObject(A a) 时，实际写入的是AProxy对象（代理类），则可以使用readResolve和writeReplace。
- 在类A中实现writeReplace方法（当ObjectOutputStream.writeObject(A)时调用该方法）
- Object writeReplace() throws ObjectStreamException。
- 在类AProxy中实现 readResolve 方法（当ObjectInputStream.readObject(A)时调用该方法）
- Object readResolve() throws ObjectStreamException。
import java.io.*;
public class Serialize07
{
public static void main(String[] args) throws Exception{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
out.writeObject(new Person("admin",20));
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
Person person = (Person)in.readObject();
System.out.println(person);
}
} class PersonProxy implements Serializable
{
String data;
public PersonProxy(Person person)
{
data = person.name+","+person.age;
}
private Object readResolve() throws ObjectStreamException
{
System.out.println("调用了readResolve方法");
String name = data.split(",")[0];
int age = Integer.parseInt(data.split(",")[1]);
Person person = new Person(name,age);
return person;
}
}
class Person implements Serializable
{
String name;
int age;
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
private Object writeReplace() throws ObjectStreamException
{
System.out.println("调用了writeReplace方法");
return new PersonProxy(this);
}
public String toString()
{
return "name=" + name + ",age=" + age;
}
}
Externalizable接口
用途：自定义流格式，比如类A没有实现序列化，而类B继承类A，而类B需要负责包括超类数据的保存和恢复。
实现方法：
- void writeExternal(ObjectOutput out) throws IOException
- void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
从API中可以看出，Externalizable接口实现了Serializable接口。
如果一个类A实现了Externalizable接口，则
- ObjectInputStream.readObject()时会调用readExternal()，而不是readObject()
- ObjectOutputStream.writeObject()时会调用writeExternal()，而不是writeObject()
当ObjectInputStream.readObject()时，过程如下：
- 假设读取类A的对象，则首先调用类A的无参构造函数(只有在实现Externalizable接口时才会调用无参构造函数)，因此我们必须要实现这个构造函数。
- 因为类A实现了Externalizable接口，则调用readExternal()。
import java.io.*;
public class Serialize06
{
public static void main(String[] args) throws Exception{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
out.writeObject(new Employee("admin",20,1000));
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
Employee person = (Employee)in.readObject();
System.out.println(person);
}
} class Person
{
String name;
int age;
public Person()
{
}
}
class Employee extends Person implements Externalizable
{
transient double salary;
public Person()
{
}
public Employee(String name,int age,double salary)
{
this.name = name;
this.age = age;
this.salary = salary;
}
public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
{
name = in.readUTF();
age = in.readInt();
salary = in.readDouble();
}
public void writeExternal(ObjectOutput out)throws IOException
{
out.writeUTF(name);
out.writeInt(age);
out.writeDouble(salary);
}
public String toString()
{
return "name=" + name + ",age=" + age + ",salary=" + salary;
}
}
Reference
[1]http://www.ibm.com/developerworks/cn/java/j-5things1/
[2]Java核心技术(第7版) P617~637