java 序列化原理与示例

序列化是干什么的 

简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保 存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。

什么情况下需要序列化

1. 当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
2. 当你想用套接字在网络上传送对象的时候；
3. 当你想通过RMI，RPC传输对象的时候；
4. 构建分布式服务框架。

什么样的对象允许序列化

(1)通过实现接口java.io.Serializable实现：此接口无任何方法，仅仅表明可以做序列化和反序列化操作。

 反序列化不会调用构造函数,不会序列化static, transient.

下面标准签名的函数可以控制序列化。

private void readObject(ObjectInputStream)

private void writeObject(ObjectOUtputSteam)

readResolve会在readObject调用之后自动调用,它最主要的目的就是让恢复的对象变个样,最主要应用场合就是单例、枚举类型的保护性恢复

readResolve在完全采用默认序列化方式时也会调用， 仅仅在有writereplace标签是不会调用 

private void readObjectNoData()throws ObjectStreamExceptionL:反序列化时如果流中没有超类对象的数据，会调用超类的readObjectNoData对对象进行初始化。

 

写了writeReplace标准签名，不会调用readobject, writeobject, readresolve. 因为writereplace可能会返回完全不同的类。

private Object writeReplace()throws ObjectStreamException

 如果是相同的类调用顺序为, writereplace, writeobject, readobject,  readresolve

(2)实现接口Externalizable：实现此接口的类，无法采用默认序列化方式，完全由自身来控制序列化。

 　　强制实现接口 , 并且必须要有无参构造函数

 void writeExternal(ObjectOutput out) throws IOException; // 串行化
 void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; // 反串行化
不会调用writeobject, readobject, writereplace
在readExternal调用后，会调用readresolve函数
有writereplace标签，不会调用writeExternal, readExternal, readresolve。 因为writereplace可能会返回完全不同的类.
相同的类调用顺序 writeReplace, writeExternal, readExternal, readresolve

示例代码：

package serial;


import java.io.*;

/**
 * Created by on 16/9/24.
 */
public  class SpecialTest implements Serializable {

    private String name;

    public SpecialTest(){

    }

    public SpecialTest(String name){
        this.name = name;
    }
    private String getMethodName() {
        StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
        StackTraceElement e = stacktrace[2];
        String methodName = e.getMethodName();
        return methodName;
    }

    private void readObject(ObjectInputStream objectInputStream)throws Exception{
        System.out.println(getMethodName());
        objectInputStream.defaultReadObject();
       //this.name = objectInputStream.readUTF();
    }

    private void readObjectNoData(){
        System.out.println(getMethodName());
    }

   private void writeObject(ObjectOutputStream objectOutputStream)throws Exception{
        objectOutputStream.defaultWriteObject();
        //objectOutputStream.writeUTF("change");
        System.out.println(getMethodName());
    }

    private Object writeReplace() throws ObjectStreamException{
        System.out.println(getMethodName());
        return new SpecialTest(getMethodName()+":C++ World");
    }

    private Object readResolve() throws ObjectStreamException{
        System.out.println(getMethodName());
        return new SpecialTest(getMethodName()+this.name+" modify");
    }


    public static  void main(String [] args)throws IOException,ClassNotFoundException{
        SpecialTest specialTest = new SpecialTest("Java World");

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);


        objectOutputStream.writeObject(specialTest);

        objectOutputStream.close();
        System.out.println("...........");
        ObjectInputStream objectInputStream  = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
        Object result = objectInputStream.readObject();
        objectInputStream.close();

        System.out.println(result);

    }

    @Override
    public String toString(){
        return String.format("name=%s", this.name==null?"null":this.name);
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(getMethodName()+":"+this.name);
        System.out.println(getMethodName());
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = in.readUTF();
        System.out.println(getMethodName());
    }
}

     

对象中的那些元素会被序列化

a）序列化时，只对对象的状态进行保存，而不管对象的方法； 
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口； 
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化，此引用对象必须是可序列化的，否者会产生异常；

d)可序列化的类的子类都可以序列化， 要使不可序列化的类的子类序列化，不可序列化的父类必须有无参构造函数。

 

 

 

http://blog.csdn.net/lirx_tech/article/details/51303966

http://blog.csdn.net/lixiaoxiong55/article/details/51373414

http://www.ibm.com/developerworks/cn/java/j-5things1/