学步园

该说的都在注释中说完了。直接给程序吧。

package test.javaPuzzler.p5;

import java.io.*;
import java.io.ObjectInputStream.GetField;
import java.io.ObjectOutputStream.PutField;

// 转载请注明来自http://blog.csdn.net/sunxing007
// 一个类实现Serializable来表明自己可以被序列化；
// 有一点需要特别注意的是：
// 如果子类实现了Serializable，而父类没有，则父类不会被序列化；
public class SerializableObject implements Serializable {

	// 生成的序列化版本号会因为编译环境，声明的类名，成员名称和数量的变化而不同；
	// 也就是说这个版本号一定程度上记录着类的定义性的信息，如果类的定义变化了，最好重新生成版本号；
	// 如果新的代码使用了旧的版本号，则在反序列化的时候，可以兼容读取旧类的字节码而不会报错；
	private static final long serialVersionUID = 9038542591452547920L;

	public String name;
	public String password;
	// 如果你不希望某个非静态成员被序列化，可以用transient来修饰它；
	public transient int age;
	// 静态成员不会被序列化，因为序列化保存的是实例的状态信息，而静态成员是类的状态信息；
	public static int version = 1;

	public SerializableObject(String name, String password) {
		this.name = name;
		this.password = password;
	}

	// 每个类可以写一个writeObject方法，这个方法将会负责该类自身的序列化过程；
	// 比如对于敏感信息如password，可以加密之后再序列化；
	// 这个过程需要用到PutField，它可以指定哪些域会被序列化，怎么序列化(比如加密);
	// 如果没有定义这个方法，将会调用ObjectOutputStream 的 defaultWriteObject；

	// 你可以注释掉readObject方法，然后运行测试用例来测试密码是否被加密；
	private void writeObject(ObjectOutputStream out) throws IOException {
		PutField putFields = out.putFields();
		putFields.put("name", name);
		// 模拟加密密码
		putFields.put("password", "thePassword:" + password);
		out.writeFields();
	}

	// 每个类可以写一个readObject方法，该方法负责该类自身的反序列化过程；
	// 比如对序列化时加密后的密码解密；
	// 这个过程需要用到GetField，他可以具体地读取每个域；或执行解密动作等等；
	// 如果没有定义这个方法，将会调用ObjectInputStream 的 defaultReadObject；
	private void readObject(ObjectInputStream in)
			throws ClassNotFoundException, IOException {
		GetField readFields = in.readFields();
		// 读取到成员的值之后，直接赋给该域，即完成该域的反序列化；
		name = (String) readFields.get("name", "defaultName");
		// 模拟解密密码
		String encPassword = (String) readFields.get("password",
				"thePassword:defaultValue");
		password = encPassword.split(":")[1];
	}

	// 序列化
	// 主要用到ObjectOutputStream；
	public void save() throws IOException {
		FileOutputStream fout = new FileOutputStream("e:\\obj");
		ObjectOutputStream oout = new ObjectOutputStream(fout);
		oout.writeObject(this);
		oout.close();
		fout.close();
	}

	// 反序列化
	// 主要用到ObjectInputStream
	public static SerializableObject load() throws IOException,
			ClassNotFoundException {
		FileInputStream fin = new FileInputStream("e:\\obj");
		ObjectInputStream oin = new ObjectInputStream(fin);
		Object o = oin.readObject();
		return (SerializableObject) o;

	}

	@Override
	public String toString() {
		return "name: " + name + ", password: " + password;
	}

	// 测试用例
	public static void main(String[] args) throws IOException,
			ClassNotFoundException {
		SerializableObject so = new SerializableObject(
				"http://blog.csdn.net/sunxing007", "123456");
		so.save();
		System.out.println(so);
		System.out.println(SerializableObject.load());
	}

}

序列化会对单例模式不利, 因为可以通过反序列化而破坏单例. 这个时候就要请出readResolve这个方法了. 比如下面的程序:

public class Dog extends Exception {
	//private static final long serialVersionUID = -7156412195888553079L;
	public static final Dog INSTANCE = new Dog();
	private Dog() { }
	public String toString() {
		return "Woof";
	}
	// 通过readResolve, 保证反序列化的时候能完全自主地处理返回对象.
	private Object readResolve(){
            return INSTANCE;
        }
	public static void main(String[] args) throws IOException, ClassNotFoundException{
		Dog d = Dog.INSTANCE;
		ByteArrayOutputStream bro = new ByteArrayOutputStream();
		ObjectOutputStream oout = new ObjectOutputStream(bro);
		oout.writeObject(d);
		ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(bro.toByteArray()));
		Dog d1 = (Dog)oin.readObject();
		System.out.println(d1==d);
	}
}

[转载请注明来自http://blog.csdn.net/sunxing007]