Java的序列化

我理解的序列化就是 -

 

将程序中的实时(Run-Time)的对象进行持久化 (专家说这是light-weight persistance). 最常见的做法就是可以将整个对象的瞬时状态(对象在某一程序执行过程中某一个时刻的状态. :). )存放到一个文件中. 废话少说， 直接给个例子，网上很多，我这个例子是原创 -

 

 

package com.droiyan.serialization;

import java.util.Date;
import java.io.*;

public class TestSerialization {

	public static void main(String[] args) throws FileNotFoundException,
			IOException, ClassNotFoundException {
		EBook ebook = new EBook("computer", "Thinking in java", new Date(), 600);
		// 在序列化之前打印出该对象
		System.out.println(ebook);

		// 将对象写入文件
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
				"droiyan.out"));
		out.writeObject(ebook);
		out.close();

		// 从文件中生成的对象流中获取对象
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(
				"droiyan.out"));

		// 打印序列化以后从文件重新载入的对象
		EBook recoveredEBook = (EBook) in.readObject();
		in.close();
		System.out.println(recoveredEBook);
	}
}

class EBook implements Serializable {
	String type;
	String name;
	Date issueDate;
	int totalPage;

	// 默认的构造函数
	public EBook() {

	}

	// 带有参数的构造函数
	public EBook(String type, String name, Date issueDate, int totalPage) {
		this.type = type;
		this.name = name;
		this.issueDate = issueDate;
		this.totalPage = totalPage;
	}

	public String toString() {
		return "Type: " + this.type + "name: " + this.name + "issueDate: "
				+ this.issueDate + "totalPage: " + this.totalPage;
	}
}

  

这个程序的输出是  -

 

Type: computername: Thinking in javaissueDate: Wed Aug 05 22:45:21 CST 2009totalPage: 600
Type: computername: Thinking in javaissueDate: Wed Aug 05 22:45:21 CST 2009totalPage: 600

  

 

另外在我机器上产生了一个droiyan.out这样的文件 ：

 

C:\Documents and Settings\Administrator\workspace\TIJ-Serialization\droiyan.out

 

 

 这个程序让我学习到  - 

 -- 一个对象想对它进行序列化，那么它的类是实现Serializable接口的. (注意：我没说一定。)

 -- 对象可以放到文件中，然后通过文件可以恢复这个对象。和数据库持久化的概念差不多。我觉得这个比较强大。

 -- 写对象是通过ObjectOutputStream.writeObject来做到，重新获取 对象可以通过ObjectOutputStream.readObject来拿到(能拿到的是up-casting的Object, 需要强制类型转换。

 

上面的例子没有凸显出“序列”的意思来，如果在写入EBook对象之前，我也写入了一个String对象，比如说 -

 

// 将对象写入文件
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
				"droiyan.out"));
		out.writeObject("This is my second input,faint.");
		out.writeObject(ebook);
		out.close();

 

 

然后我在读取对象的时候 -

 

// 打印序列化以后从文件重新载入的对象
		String mycomment = (String) in.readObject();
		EBook recoveredEBook = (EBook) in.readObject();
		in.close();
		System.out.println(mycomment);
		System.out.println(recoveredEBook);

 

 

这里要注意，因为是说对象是按照一定的序列进入到流中，那么读取的时候也是按照写入流的顺序。我的例子中是先写入String对象，然后是EBook对象；读取的时候也是如此。如果我颠倒读取对象的顺序会出现 -

 

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to com.droiyan.serialization.EBook
 at com.droiyan.serialization.TestSerialization.main(TestSerialization.java:27)

 

那么我又学习到了 -

-- Java对象的序列化原来是安装一定的顺序读对象，然后再安装这个顺序写对象。所以叫序列化。

 

实际上测试到这里，我就比较好奇序列化到底产生一个什么样的文件，并且在读取这个文件的时候为什么可以魔法般的就可以生成对象呢？我现在的理解是 - 这是java序列化的内幕，如果有达人知道更多，请指点一二。

 

Java的反序列化会试图去找所有已经序列化后的Object对象的class文件, 如果找不到， 反序列化的成功将会失败。 比如说， 在同一个目录上我又创建一个新的java文件去从文件中获取对象 - 但在此之前我将先前序列化生成的EBook.class给删除.

 

package com.droiyan.serialization;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class TestReloadObjectWithoutClass {

	public static void main(String[] args) throws FileNotFoundException,
			IOException, ClassNotFoundException {
		// 从文件中生成的对象流中获取对象
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(
				"droiyan.out"));

		// 打印序列化以后从文件重新载入的对象
		String mycomments = (String) in.readObject();
		EBook recoveredEBook = (EBook) in.readObject();
		in.close();
		System.out.println(mycomments);
		System.out.println(recoveredEBook);

	}
}

  

 

 然后我就得到了下面的错误 -

 

Exception in thread "main" java.lang.ClassNotFoundException: com.droiyan.serialization.EBook
	at java.net.URLClassLoader$1.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)
	at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)
	at java.lang.ClassLoader.loadClassInternal(Unknown Source)
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Unknown Source)
	at java.io.ObjectInputStream.resolveClass(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 com.droiyan.serialization.TestReloadObjectWithoutClass.main(TestReloadObjectWithoutClass.java:17)

  

 

 

  从这个错误中，我们可以发现一些反序列化过程的蛛丝马迹.

 

  at java.io.ObjectInputStream.resolveClass(Unknown Source)

 

从stream中得到class的相关信息，然后在当前的classpath中试图去载入相关的class.

而是我又学会了 -

 

-- Java的反序列化在重新还原对象的时候，需要在当前的classpath中找到所有序列化后的Object对应的字节码文件才能保证反序列化顺利进行。

 

 PS : 第一次写完以后， 编辑了一下再保存， 结果......我又搞了 1 遍。