Java序列化的使用

准备一个枚举类，枚举类都继承了父类Enum，而Enum又实现了Serializable接口，所以enum类都可直接序列化

package serializable;

public enum Gender {
	MALE,FEMALE
}

简单示例
准备需要序列化的类Person，里面有属性name，age，gender。

package serializable;

import java.io.Serializable;


public class Person implements Serializable{

	private static final long serialVersionUID = 1L;
	private String name = null;
	private Integer age = null;
	private Gender gender = null;
	
	public Person(String name, Integer age, Gender gender) {
		System.out.println("arg 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 + "]";
	}
	
}

序列化的过程就是将类从一个状态读出并保存的过程。使用ObjectOutputStream 的writeObject方法读出，使用ObjectInputStream 的readObject方法读入。

package serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SimpleSerial {
	
    public static void main(String[] args) throws Exception {
        File file = new File("person.out");

        ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
        Person person = new Person("John", 101, Gender.MALE);
        oout.writeObject(person);
        oout.close();

        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
        Object newPerson = oin.readObject(); // 没有强制转换到Person类型
        oin.close();
        
        System.out.println(person);
        System.out.println(newPerson);
        
        System.out.println(person.equals(newPerson));
    }
}

这里可以看到，前后产生的对象并不相同。

arg constructor
Person [name=John, age=101, gender=MALE]
Person [name=John, age=101, gender=MALE]
false

transient关键字
如果有些敏感的字段我们并不希望被序列化，可以使用transient关键字使得字段避免被序列化。
在属性上添加transient关键字如下：

	private transient Integer age = null;
	private transient Gender gender = null;

其他的不做改变，得到如下结果：

arg constructor
Person [name=John, age=101, gender=MALE]
Person [name=John, age=null, gender=null]
false

以上可以看出transient关键字避免了属性的序列化。

默认序列化
如果没有使用transient关键字，name属性在序列化的时候使用的就是默认序列化的方式。ObjectOutputStream提供了defaultWriteObject对属性进行序列化，ObjectInputStream 同理。
在Person类中添加下面两个方法，其他地方不做修改：

	private void writeObject(ObjectOutputStream out) throws IOException {
		out.defaultWriteObject();
		out.writeInt(age);
	}
	
	private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException {
		in.defaultReadObject();
		age = in.readInt();
	}

有如下结果：

arg constructor
Person [name=John, age=101, gender=MALE]
Person [name=John, age=101, gender=null]
false

以上可以推断出即使字段使用了transient关键字，仍然可以被序列化成功并读取出来。而没有做修改的gender属性还是null值。

serialVersionUID
我们序列化和反序列化的时候都会用到这个serialVersionUID，它是来验证类的版本一致的，如果前后序列化serialVersionUID不同，就会报错。
接下来，我们将实现类稍作修改：

package serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SimpleSerial {
	static File file = new File("person.out");
	public static void main(String[] args) throws Exception{
		// serizableIn();
		serizableOut();
	}
    // 序列化
    public static void serizableIn() throws Exception {
        ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
        Person person = new Person("John", 101, Gender.MALE);
        oout.writeObject(person);
        System.out.println(person);
        oout.close();
    }
    // 反序列化
    public static void serizableOut() throws Exception {
        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
        Object newPerson = oin.readObject(); // 没有强制转换到Person类型
        System.out.println(newPerson);
        oin.close();
    }
}

先运行serizableIn()方法，使得类先序列化，然后修改serialVersionUID(由默认值1修改为了11)，注释掉serizableIn()，运行serizableOut()。
报错结果：

Exception in thread "main" java.io.InvalidClassException: serializable.Person; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 11
	at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
	at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
	at java.io.ObjectInputStream.readClassDesc(Unknown Source)
	at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
	at java.io.ObjectInputStream.readObject0(Unknown Source)
	at java.io.ObjectInputStream.readObject(Unknown Source)
	at serializable.SimpleSerial.serizableOut(SimpleSerial.java:50)
	at serializable.SimpleSerial.main(SimpleSerial.java:37)

获取相同对象
从之前的示例可以知道，序列化前后的对象并不相同，name如何使得前后的对象一致呢。
首先使用单例模式，其次添加readResolve()方法返回对象实例，虚拟机在反序列化时会将readResolve()方法返回的对象覆盖反序列化生成的对象，这样就可以保证前后对象的一致性。不过值得注意的是，这样序列化前后的字段在文件中的确是可选择的，但是readResolve()使得字段的似乎没按照要求序列化，但其实是按照要求的。
添加下列方法在Person类中：

   private static class InstanceHolder {
        private static final Person instatnce = new Person("John", 31, Gender.MALE);
    }

    public static Person getInstance() {
        return InstanceHolder.instatnce;
    }
    
    private Object readResolve() throws ObjectStreamException {
        return InstanceHolder.instatnce;
    }

main方法调用如下：

package serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SimpleSerial {
	static File file = new File("person.out");


    public static void main(String[] args) throws Exception {
        

        ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream(file));
        Person person = Person.getInstance();
        person.setAge(111);
        oout.writeObject(person);
        oout.close();

        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));
        Object newPerson = oin.readObject(); // 没有强制转换到Person类型
        oin.close();
        
        System.out.println(person);
        System.out.println(newPerson);
        
        System.out.println(person.equals(newPerson));
    }
}

结果如下：

arg constructor
Person [name=John, age=111, gender=MALE]
Person [name=John, age=111, gender=MALE]
true