Serilizable 和 Externalizable 学习
本文是我对Java对象序列化的学习与理解
1、什么是Java对象序列化
Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行状态时，这些对象才能存在，即，这些对象的生命周期不会比JVM更长。但在现实中，就可能要求在JVM运行停止后能够保存（持久化），以便下次运行时重新获取对象，Java对象序列化就能够帮助我们实现该功能。
使用Java对象序列化保存对象时，会把其状态保存为一组字节，在下次调用时，再将这些字节装入对象。需要注意的是，对象序列化保存的是对象的“状态”，即它的成员变量。哟偶次可知，对象序列化不会关注类中的静态变量。
除了在持久化对象时会用到对象序列化外，当使用RMI（远程方法调用），或者网络传递对象时，也会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制,简单易用。
2、实现序列化的步骤
a) Make a FileOutputStream
FileOutputStream fs = new FileOutputStream("foo.ser");
b) Make a ObjectOutputStram
ObjectOutputStream os = new ObjectOutputStream(fs);
c) Write to object
os.writeObject(myObject1);
os.writeObject(myObject2);
os.writeObject(myObject3);
d) Close the ObjectOutputStram
os.close();
3、简单实例
在Java中，一个类只需要实现java.ioo.Serilizable接口，那么它就可以被序列化，看下面一个简单示例：
在Person.java类中Gender为一个枚举类型，表示性别，大家应该了解每个枚举类型默认继承类java.lang.Enum,而该类实现了Serializable接口，所以默认的所有枚举类型都可以被序列化。
在Person中有三个私有成员变量，name,age,gender，实现了Serializable接口，
enum Gender{
MALE,FEMALE
}
public class Person implements Serializable
{
private String name;
private int age;
private Gender gender;
public Person(){
System.out.println("Person无参构造函数");
}
public Person(String name,int age,Gender gender) {
System.out.println("Person有参构造函数");
this.name = name;
this.age = age;
this.gender = gender;
}
// 省略get和set方法以及toString方法
}
SimpleSerial.java是程序的入口，先将Person对象保存到person.out中，然后再从该文件中读取到Person对象中，并打印出结果。
public class SimpleSerial {
public static void main(String[] args) {
File file = new File("person.out");
try {
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person person = new Person("susu",21,Gender.FEMALE);
oos.writeObject(person);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Object operson = ois.readObject();
ois.close();
System.out.println(operson);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
上述代码的结果为：
Person有参构造函数
Person [name=susu, age=21, gender=FEMALE]
注意：
- 此时需要注意的是，当重新获取被保存的Person对象时，并没有调用构造方法，看起来像是直接使用字节将对象还原出来。
- 当Person对象保存到person.out文件后，我们可以在其他地方读取到该文件的还原对象，但必须确保取程序的CLASSPATH中包含Person.class。
4、默认序列化机制
如果仅仅只是让某个类实现Serializable接口，而没有其他处理的话，则就是使用默认序列化机制。使用默认机制，在序列化对象时，不仅会序列化当前对象本身，还会对该对象引用的其他对象也进行序列化，同样的，这些其他对象引用的另外对象也将被序列化，以此类推。所以，如果一个对象的成员变量是容器类对象，而这些容器含有的元素也是容器类对象，那么这个序列化对象的过程就会很复杂，开销也很大。
5、影响序列化
在现实中，有些是默认不使用序列化的，比如，希望在序列化过程中忽略掉敏感数据，或者简化序列化过程。下面介绍相关方法：
5.1、使用transient关键字
当某字段使用transient关键字后，默认化序列将会忽略该字段。此处将Person中的age声明为transient，如下所示：
public class Person implements Serializable //Externalizable
{
......
transient private int age;
......
}
运行结果为：
Person有参构造函数
Person [name=susu, age=0, gender=FEMALE]
可以看出，没有获取到age的值，
5.2、writeObject()方法与readObject()方法
对于上述已经被stransitive序列化的字段，除了将stransitive关键字去掉以外，还可以用writeObject()方法与readObject()方法再次序列化age。先上代码吧：
public class Person implements Serializable
{
......
transient private int age;
......
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
在writeObject（）方法中会先调用ObjectOutputStream中的defaultWriteObject（）方法，该方法会执行默认的序列化机制，此时对忽略掉age字段，然后调用writeInt（）方法显示将age字段写入到ObjectOutputStream中，readObject（）的作用是针对对象的读取，其原理与writeObject（）方法相同。
再次运行，结果如下：
Person有参构造函数
Person [name=susu, age=21, gender=FEMALE]
6、 Enternalizable接口
在JDK中，提供了另外一种序列化的接口--Enterbalizable,使用该接口后，以前基于Serializable接口的序列化机制将会无效。
其实在这里，我有个疑问，我查看了文档，发现Enternalizable继承自Serializable，但为什么这里会失效呢，目前还不是很懂。
Person改为实现Enternalizable接口后代码如下：
public class Person implements Externalizable {
private String name;
transient private int age;
private Gender gender;
public Person(){
System.out.println("Person无参构造函数");
}
public Person(String name,int age,Gender gender) {
System.out.println("Person有参构造函数");
this.name = name;
this.age = age;
this.gender = gender;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(age);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
age = in.readInt();
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
}
// 省略get和set，toString方法
}
运行结果如下：
Person有参构造函数
Person无参构造函数
Person [name=null, age=0, gender=null]
从运行结果来看，一方面看出Person对象中任何一个字段都没有被序列化。另一方面，发现调用了Person的无参构造方法。
Externalizable继承于Serializable，当使用该接口时，序列化的细节需要由程序员去完成。如上所示的代码，由于writeExternal()与readExternal()方法未作任何处理，那么该序列化行为将不会保存/读取任何一个字段。这也就是为什么输出结果中所有字段的值均为空。
另外，若使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。
对上述Person类作进一步的修改，使其能够对name与age字段进行序列化，但要忽略掉gender字段，如下代码所示：
public class Person implements Externalizable //Serializable
{
......
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
name = (String) in.readObject();
age = in.readInt();
}
}
运行结果如下：
Person有参构造函数
Person无参构造函数
Person [name=susu, age=21, gender=null]