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]