Java Serializable（序列化）的理解和总结

参考资料：http://www.cnblogs.com/yangjian-java/p/7813623.html

一、序列化是干什么的？

       Java平台容许咱们在内存中建立可复用的Java对象，但通常状况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。

       但在现实应用中，就可能要求在JVM中止运行以后可以保存(持久化)指定的对象，并在未来从新读取被保存的对象。Java对象序列化就可以帮助咱们实现该功能。

       使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在将来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的"状态"，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量！！！

       除了在持久化对象时会用到对象序列化以外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用，之后笔者会逐步介绍之。

二、什么状况下须要序列化   
       a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
       b）当你想用套接字在网络上传送对象的时候；
       c）当你想经过RMI传输对象的时候；

简而言之:序列化的做用就是为了避免同jvm之间共享实例对象的一种解决方案.由java提供此机制,效率之高,是其余解决方案没法比拟的.自家的东西嘛.

三、简单示例

首先建立一个Person类

import java.io.Serializable;

public class Person implements Serializable{
    private String name;
    private Integer age;
    private Gender gender;
    
    public Person() {
        System.out.println("Persong no arg constructor");
    }

    public Person(String name, Integer age, Gender gender) {
        System.out.println("Persong all args constructor");
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
    }
}

PS:该类必须实现Serializable接口，不然会报java.io.NotSerializableException: serializable.Person的错误（读者不仿一会试试去掉Serializable试试）

其中,Gender是个枚举类

/**
 *  性别枚举类
 */
public enum Gender {
   MALE,FEMALE;
}

/**
 * 每一个枚举类型都会默认继承类java.lang.Enum，而该类实现了Serializable接口，因此枚举类型对象都是默承认以被序列化的
 */ 

下面，就是测试代码：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SimpleSerializableTest {
    public static void main(String[] args)throws Exception { 
        //首先，指定输出文件
        File file = new File("person.out");
        //建立一个FileOutputStream
        FileOutputStream fo = new FileOutputStream(file);
        //建立一个ObjectOutputStream
        ObjectOutputStream    oo = new ObjectOutputStream(fo);
        //建立一个Person对象
        Person person = new Person("李同窗",18,Gender.MALE);
        oo.writeObject(person);
        oo.close();
        
        //再将person读出来
        //建立一个ObjectInputStream
        ObjectInputStream oi = new ObjectInputStream(new FileInputStream(file));
        Object readObject = oi.readObject();
        oi.close();
        System.out.println(readObject);
    }
}

运行这段代码，你将看到以下输出：

Persong all args constructor  //这个是在建立Person的时候调用的
Person [name=李同窗, age=18, gender=MALE] //这个实在最后打印readObject的时候调用的

咱们能够看到，咱们成功将建立的对象写入到person.out文件中，而后经过readObject将其读出来（是读出一个已序列化的对象，即直接使用字节将Person对象还原出来的，而不是new一个，能够看到也没有调用构造器嘛）

然，当Person对象被保存到person.out文件中以后，咱们能够在其它地方去读取该文件以还原对象，以下面代码：

import java.io.File;
import java.io.FileInputStream; 
import java.io.ObjectInputStream; 

public class OtherReadPersonSerializable {
    public static void main(String[] args)throws Exception {  
        File file = new File("person.out");
        ObjectInputStream oi = new ObjectInputStream(new FileInputStream(file));
        Object otherRead = oi.readObject();
        oi.close();
        System.out.println(otherRead);
    }
}

仍然能够输入以下内容：

Person [name=李同窗, age=18, gender=MALE]

但必须确保该读取程序的CLASSPATH中包含有Person.class(哪怕在读取Person对象时并无显示地使用Person类，如上例所示)，不然会抛出ClassNotFoundException。

四、Serializable的做用

      为何一个类实现了Serializable接口，它就能够被序列化呢？在上节的示例中，使用ObjectOutputStream来持久化对象，在该类中有以下代码：

 1           if (obj instanceof String) {
 2                 writeString((String) obj, unshared);
 3             } else if (cl.isArray()) {
 4                 writeArray(obj, desc, unshared);
 5             } else if (obj instanceof Enum) {
 6                 writeEnum((Enum<?>) obj, desc, unshared);
 7             } else if (obj instanceof Serializable) {
 8                 writeOrdinaryObject(obj, desc, unshared);
 9             } else {
10                 if (extendedDebugInfo) {
11                     throw new NotSerializableException(
12                         cl.getName() + "\n" + debugInfoStack.toString());
13                 } else {
14                     throw new NotSerializableException(cl.getName());
15                 }
16             }

看代码第7行，作了Serializable类型判断，从这段代码中也能够知道，能够被序列化的是String，Array，Enum以及实现了Serializable接口的类

五、默认序列化机制
        若是仅仅只是让某个类实现Serializable接口，而没有其它任何处理的话，则就是使用默认序列化机制。使用默认机制，在序列化对象时，不只会序列化当前对象自己，还会对该对象引用的其它对象也进行序列化，一样地，这些其它对象引用的另外对象也将被序列化，以此类推。因此，若是一个对象包含的成员变量是容器类对象，而这些容器所含有的元素也是容器类对象，那么这个序列化的过程就会较复杂，开销也较大。

六、 影响序列化
    在现实应用中，有些时候不能使用默认序列化机制。好比，但愿在序列化过程当中忽略掉敏感数据，或者简化序列化过程。下面将介绍若干影响序列化的方法。

    6.1 transient关键字

    当某个字段被声明为transient后，默认序列化机制就会忽略该字段。好比，将Person中age生命为transient：

transient private Integer age;

    那么，当你再运行SimpleSerializableTest 的时候，就会有以下输出：

Persong all args constructor

Person [name=李同窗, age=null, gender=MALE]

   你看，这个时候age就为null了，未被序列化到person.out中。

   6.2 writeObject()方法与readObject()方法

    对于上述已被声明为transitive的字段age，除了将transitive关键字去掉以外，是否还有其它方法能使它再次可被序列化？方法之一就是在Person类中添加两个方法：writeObject()与readObject()，以下所示：

public class Person implements Serializable {
    private String name;
    transient private Integer age; //未去掉transient
    private 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();
    }
       ...
       // 其余不变
}

       在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法，该方法会执行默认的序列化机制，如6.1节所述，此时会忽略掉age字段。而后再调用writeInt()方法显示地将age字段写入到ObjectOutputStream中。readObject()的做用则是针对对象的读取，其原理与writeObject()方法相同。

Persong all args constructor
Person [name=李同窗, age=18, gender=MALE]

      必须注意地是，writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。详情可见ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。