Serializable序列化(四)

package serializ;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 我们知道有些类是单例
 * 如果序列化之后再反序列化,之前说过正常方式反序列化
 * 生成的对象肯定不一样,比如内存地址不一样
 * 那就打破了单例只有一个实例的设计与初衷
 * 如何保证在同一个应用里面反序列化之后仍然是同一个对象呢
 * 除了实现Serializable接口,还要实现一个方法
 * protected Object readResolve()
 * 
 * @author yli
 *
 */
public class SingletonSerializable {
	
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		System.out.println("内存地址===>" + s1);
		
		String file = "src/serializ/singleton.dat";
		writeObject(s1, file);
		
		Singleton s2 = (Singleton)readObject(file);
		
		System.out.println(s1 == s2);
		
	}
	

	// 序列化对象
	private static void writeObject(Object obj, String file) {
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
			oos.writeObject(obj);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	// 反序列化
	private static Object readObject(String file) {
		ObjectInputStream ois = null;
		Object obj = null;
		try {
			ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(file)));
			obj = ois.readObject();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return obj;
	}

}

class Singleton implements Serializable {
	
	private static final long serialVersionUID = -7159883960112615379L;
	private final static Singleton onlyOne = new Singleton();
	
	/**
	 * 私有构造方法保证从外部无法创建新对象
	 * 不过java的反射机制可以利用setAccessable(true)可以调用到
	 * 这是后话了...
	 */
	private Singleton(){
		
	}
	
	/**
	 * 通过静态方法获得唯一的实例
	 * @return
	 */
	public static Singleton getInstance(){
		return onlyOne;
	}
	
	/**
	 * 要保证反序列化之后返回的还是唯一的实例对象
	 * 则要实现 readResolve方法
	 * 该方法会在反序列化之后被自动调用
	 * @return
	 */
	protected Object readResolve() {
		return getInstance();
	}
}