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

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

1、序列化是干什么的？

       java平台允许我们在内存中创建可复用的java对象，但一般情况下，只有当jvm处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比jvm的生命周期更长。

       但在现实应用中，就可能要求在jvm停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。java对象序列化就能够帮助我们实现该功能。

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

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

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

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

3、简单示例

首先创建一个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。

4、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接口的类

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

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

    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方法。