JAVA序列化/反序列化与单例

单例设计类:

    Java代码   
    
  
package com.test.singleton;  
  
import java.io.IOException;  
import java.io.ObjectStreamException;  
import java.io.Serializable;  
  
  
public class SingleTon implements Serializable{  
  
    /** 
     *  
     */  
    private static final long serialVersionUID = 768457893059530646L;  
  
    private SingleTon(){  
        System.out.println("here...");  
        //避免反射机制,导致的多例问题,通过反射机制仍然可以对私有构造函数进行操作  
        if(instance != null){  
            return;  
        }  
    }  
      
    private static final SingleTon instance = new SingleTon();  
      
    public static SingleTon getInstance(){  
        return instance;  
    }  
      
    public void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{  
        //  
    }  
    /** 
     * 严格单例,确保remote instance不会干扰单例模式,避免在发序列化过程中对单例的影响. 
     * @return 
     * @throws ObjectStreamException 
     */  
    public Object readResolve() throws ObjectStreamException{  
        return instance;  
    }  
}  

    Java代码   
    
  
///////////流方式:  
package com.test.singleton;  
  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
public class SerializeCheckMain {  
  
    /** 
    * @param args 
    */  
    public static void main(String[] args) throws Exception{  
        // TODO Auto-generated method stub  
        SingleTon s1 = SingleTon.getInstance();  
        File file = new File("D:\\singleTome.txt");  
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));  
        oos.writeObject(s1);  
        oos.close();  
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));  
        SingleTon s2 = (SingleTon)ois.readObject();  
        System.out.println("HashCode 1 : " + s1.hashCode());  
        System.out.println("HashCode 2 : " + s2.hashCode());  
        System.out.println("Equal : " + (s1 == s2));//打破单例  
    }  
  
}  

    Java代码   
    
  
//////////////////////反射方式:  
package com.test.singleton;  
  
import java.lang.reflect.Constructor;  
  
/** 
 * @author liuguanqing 
 *  反射机制,测试单例 
 */  
public class RefletCheckMain {  
  
    /** 
    * @param args 
    */  
    public static void main(String[] args) throws Exception{  
        SingleTon s1 = SingleTon.getInstance();  
        Constructor[] constructors = SingleTon.class.getDeclaredConstructors();  
        Constructor<SingleTon> c = constructors[0];  
        c.setAccessible(true);  
        SingleTon s2 = c.newInstance(null);  
        System.out.println("HashCode 1 : " + s1.hashCode());  
        System.out.println("HashCode 2 : " + s2.hashCode());  
        System.out.println("Equal : " + (s1 == s2));//打破单例  
    }  
  
}  

注意,序列化和反序列化,是java使用字节码技术生成对象,将不会执行构造器方法.

注意到在writeReplace和readResolve,我们可以严格控制singleton的对象,在同一个JVM中完完全全只有唯一的对象,控制不让singleton对象产生副本.

    Java代码   
    
  
package com.test.main;  
  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.ObjectStreamException;  
import java.io.Serializable;  
  
public class TestSerializable implements Serializable{  
  
    /** 
     *  
     */  
    private static final long serialVersionUID = -1740221592194879964L;  
  
    private Integer age;  
      
    private String name;  
      
    public TestSerializable(){  
        System.out.println("Contrustor..");  
    }  
      
    public Integer getAge() {  
        return age;  
    }  
  
  
    public void setAge(Integer age) {  
        this.age = age;  
    }  
  
  
    public String getName() {  
        return name;  
    }  
  
  
    public void setName(String name) {  
        this.name = name;  
    }  
      
    private void writeObject(java.io.ObjectOutputStream out) throws IOException{  
        System.out.println("writeObject");  
        out.writeInt(this.age);  
        out.writeInt(this.name.getBytes("utf8").length);  
        out.write(this.name.getBytes("utf8"));  
    }  
      
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{  
        this.age = in.readInt();  
        int chars = in.readInt();  
        byte[] bytes = new byte[chars];  
        in.readFully(bytes);  
        this.name = new String(bytes,"utf8");  
        System.out.println("readObject");  
    }  
      
    public Object readResolve() throws ObjectStreamException{  
        System.out.println("readResolve");  
        return this;  
    }  
      
    public Object writeReplace() throws ObjectStreamException{  
        System.out.println("writeReplace");  
        return this;  
    }  
  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) throws Exception{  
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\sss.txt"));  
        TestSerializable ss = new TestSerializable();  
        ss.setAge(12);  
        ss.setName("zhangsan");  
        oos.writeObject(ss);  
        oos.close();  
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\sss.txt"));  
        TestSerializable ss2 = (TestSerializable)ois.readObject();  
        System.out.println(ss == ss2);  
        System.out.println(ss2.getName());  
        ois.close();  
        //////////执行结果  
        //Contrustor..  
        //writeReplace  
        //writeObject  
        //readObject  
        //readResolve  
        //false  
        //zhangsan  
          
    }  
  
}  

    Java代码   
    
  
//////////Externalizable接口是Serializable的子接口,不过此接口提供了两个特殊的扩展方法:  
    @Override  
    public void writeExternal(ObjectOutput out) throws IOException {  
        System.out.println("writeEx");  
        out.writeInt(50);  
          
    }  
  
    @Override  
    public void readExternal(ObjectInput in) throws IOException,  
            ClassNotFoundException {  
        System.out.println("readEx");  
        this.age = in.readInt();  
    }  

注意实现Externalizable接口的类,在发序列化时,将会执行构造函数,因为对于流操作而言,此对象是有明确类型的(Serializable接口是个标记接口).

而且,如果实现了writeExternal和readExternal,将不会在执行readObject和writeObject,因为此时这两个方法已经被"擦除".

对于java序列化和反序列化,被序列化的类中有关于serialVersionUID会带来一些问题;

1) 如果你调整了Class结构(比如新增/去除某个属性值,但是不能引入编译错误),但没有修改serialVersionUID;那么在反序列化和序列化时不会带来异常,只是可能导致部分属性在get时为null.

2) 如果你调整了Class结构,同时也修改了serialVersionUID;如果序列化和反序列双方没有保持uid一致的话,将会直接导致反序列化异常.(java.io.InvalidClassException)

3) 如果你没有显式的声明serialVersionUID,那么对于JVM而言,不同的class类结构(属性列表和方法列表)将会得出不同的uid;因此如果序列化双方不能保持一致的uid,仍然会带来问题.

本文转载自http://shift-alt-ctrl.iteye.com/blog/1842040

JAVA序列化/反序列化与单例

猜你喜欢