Java 7之基础 - 序列化与反序列化

转载请注明出处：http://blog.csdn.net/mazhimazh/article/details/20292331

使用Java的序列化和反序列化可以实现信息的持久存储、或者也可以实现Java对象的深克隆。在前面文章讲解过使用序列化和反序列化来实现对象克隆，如下：

Java之基础 - 深克隆与浅克隆（参见文章：http://blog.csdn.net/mazhimazh/article/details/16828505）

下面来具体讲解一下序列化。能够进行序列化的类必须要实现Serializable接口，这个接口的定义如下：

public interface Serializable {   }

class Shitt implements Serializable{  // 必须实现Serializable接口   }

将如下的类进行序列化和反序列化时继承序列化接口：

class Shitt  implements Serializable{
	private static final long serialVersionUID = 1L;
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

进行类的序列化和反序列化操作：

public static void save(Shitt t) {  // 序列化给定的类
		try {
			FileOutputStream fs = new FileOutputStream("test.txt");
			ObjectOutputStream os = new ObjectOutputStream(fs);
			os.writeObject(t);
			os.flush();
			os.close();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	public static void read() { //反序列化给定的类
		try {
			FileInputStream fs = new FileInputStream("test.txt");
			ObjectInputStream ois = new ObjectInputStream(fs);
			Shitt login = (Shitt) ois.readObject();
			System.out.println(login.getName());
			ois.close();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

需要注意的几个几点：

（1）在每个要序列化的类中加入private static final 的serialVersionUID，这样，即使在某个对象被序列化之后，它所对应的类被修改了，该对象也依然可以被正确地反序列化。举个例子：

public class MeTest{
	public static void main(String[] args) {
		Shitt t = new Shitt();
		t.setName("mazhi");
		MeTest.save(t);
		MeTest.read();

	}
        // 省略save()和read()方法	
}

mazhi

现在修改序列化类为：

class Shitt  implements Serializable{
	private static final long serialVersionUID = 1L;
	private String name;
	private int p;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getP() {
		return p;
	}
	public void setP(int p) {
		this.p = p;
	}
}

local class incompatible:
实现序列化接口的实体能够兼容先前版本,不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

（2）如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。否则就会抛出异常。或者在不实例Serializable接口时，为这个引用变量加上transient关键字即可。

首先说明一下引用类型的实例变量怎么理解，如下：

class Father{  }  // 没有实现Serializable接口

class Shitt implements Serializable{
	private String name;
	public Father t;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Shitt t = new Shitt();
		t.setName("mazhi");
		t.t=new Father();
		MeTest.save(t);
		MeTest.read();

一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

（3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

class Father{ 
	public int a;
	
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
}
class Shitt extends Father implements Serializable{
	private String name;
	public static String str="my name is mazhi";
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

在这个类中，到底哪些变量的值能够进行序列化，哪些不能呢？测试如下：

Shitt t = new Shitt();
		t.setName("mazhi");
		t.a=3;
		MeTest.save(t);
		MeTest.read();

System.out.println(login.getName()+" "+login.a);
			System.out.println(login.str);

mazhi 0
my name is mazhi

可以看出Father类没有实现序列化接口，其定义的属性不能被序列化。最需要注意的是静态变量，这个变量不被序列化，那为什么还可以读出值呢？

因为在类加载时这个变量已经存在于内存中了，而且保持着唯一，不会被垃圾回收。当再运行时，由于静态变量属于类，当然可以取出这个值了。我们可以在另外一个虚拟机上进行测试就不会出现这个问题了。

同时从这个例子还能得出一些结论：

如果一个类实现了Serializable接口，但是它的父类没有实现，那么这个类也可以序列化。需要提醒的是Object超类没有实现这个序列化的接口。为什么呢？？因为如果一个类没有实现Serializable接口，但是它的父类实现了，那么这个类也可以序列化。Object实现序列化接口意味着所有的类都可以被序列化，这一概念变得无意义，现时还会造成各种问题。

（4）序列化和反序列化过程中构造函数的调用

class Father{   // 没有实现Serializable接口
	public Father(){
		System.out.println("父类构造方法");
	}
}
class Shitt extends Father implements Serializable{
	public Shitt(){
		System.out.println("子类构造方法");
	}
}

父类构造方法
子类构造方法
父类构造方法

父类加上序列化接口后再次进行序列化和反序列化的操作，结果如下：

父类构造方法
子类构造方法

由上可以得出结论：在进行反序列化过程中还是遵守类的初始化规则，也就是先父类后子类，但是子类的初始化并不是通过调用构造函数等手段，而是从持久化文件中存储的信息进行初始化的。

扩展：

（1）其实可以在类的序列化过程中，指定属性存储的格式，例如XML，反序列化也是一样的，有兴趣的话可以参见其他资料。

（2）既然序列化和反序列化可以实现文件的持久存取，那么与其他一些持久化，例如数据库比起来又怎么样呢？

Java 7之基础 - 序列化与反序列化,布布扣,bubuko.com

Java 7之基础 - 序列化与反序列化

原文：http://blog.csdn.net/mazhimazh/article/details/20292331