java中的序列化

一、概念

对象是由一个程序创建的，当程序被关掉，对象自然就消失了。为了能够使得对象能够保存还原，甚至通过网络等传输，就有了对象序列化这个概念。我是觉得和持久化一个概念。java对象序列化最强大的一个方面是针对对象所有连环的引用都能够进行保存，并且能够反序列化。

二、实现

1.在java中对象序列化必须要继承Serializable接口，这个接口只是一个标识，标示能够进行序列化。该对象所引用的其他对象，以及其他对象所引用的其他其他对象也必须继承Serializble接口，不然序列化时会抛出异常java.io.NotSerializableException。还要生成serialVersionUID，这个ID是根据属性和方法生成的。表示版本号。如果反序列化的时候，版本号不一致就会抛出异常。

2.序列化的实现非常简单：首先要有一个ObjectOutputStream 对象 ，然后调用writeObject(Object objec)方法就行了。反序列化需要有一个ObjectInputStream对象，然后调用readObject()方法。再强行转换成你要的类就行了。

三、demo

public class Wheel implements Serializable{
	private static final long serialVersionUID = 5801095499370035805L;
	private String id;
	private String brand;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
}

public class Car implements Serializable{
	private static final long serialVersionUID = 5765553644244739065L;
	private Wheel[] wheel ;
	
	private String brand;
	
	private int price ;
	private String ow;
	public Wheel[] getWheel(  ) {
		return wheel;
	}
	public void setWheel(Wheel[] wheel) {
		this.wheel = wheel;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
}

public static void main(String[] args) throws IOException, ClassNotFoundException{
		FileOutputStream fos = new FileOutputStream(new File("/home/liubin/test.txt"));
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		Wheel[] wheel = new Wheel[4];
		wheel[0] = new Wheel();
		wheel[0].setBrand("JIATONG");
		wheel[0].setId("00001");
		wheel[1] = new Wheel();
		wheel[1].setBrand("JIATONG");
		wheel[1].setId("00002");
		wheel[2] = new Wheel();
		wheel[2].setBrand("JIATONG");
		wheel[2].setId("00003");
		wheel[3] = new Wheel();
		wheel[3].setBrand("JIATONG");
		wheel[3].setId("00004");
		
		Car car = new Car();
		car.setPrice(800000);
		car.setBrand("BMW");
		car.setWheel(wheel);
		oos.writeObject(car);
		oos.flush();
		oos.close();
		
		//反序列化
		FileInputStream fis = new FileInputStream(new File("/home/liubin/test.txt"));
		ObjectInputStream ois = new ObjectInputStream(fis);
		Object object = ois.readObject();
		ois.close();
		Car cars = (Car)object;
		System.out.println(car);
		System.out.println(cars);
		System.out.println(car == cars);
	}
}

最终Car对象写入到文件中，然后能够反序列化。

关于Externalizable这个类是继承了Serializable，但是可以实现对序列化的一些控制，就不多说了。还有一点就是transient这个关键字修饰的属性或者是方式是不参与序列化的。此外使用static修饰的属性也是不参与序列化的。