Java基础系列8：Java的序列化与反序列化

Posted 2020-07-01

一 简介

把对象转换为字节序列的过程称为对象的序列化
把字节序列恢复为对象的过程称为对象的反序列化
对象的序列化主要有两种用途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2） 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

二 Java中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中；java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回

只有实现了Serializable或Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。

对象序列化包括如下步骤：
1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2） 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：
1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2） 通过对象输入流的readObject()方法读取对象。

三 使用Serializable接口实现的实例

首先定义了一个实现了Serializable接口WebSite的实体类

package cn.zifangsky.serializable;

import java.io.Serializable;

public class WebSite implements Serializable {
	private static final long serialVersionUID = 1835573222135484360L;

	private String siteName;
	private String siteUrl;
	private String webMaster;

	public WebSite() {

	}

	public WebSite(String siteName, String siteUrl, String webMaster) {
		this.siteName = siteName;
		this.siteUrl = siteUrl;
		this.webMaster = webMaster;
	}

	public String getSiteName() {
		return siteName;
	}

	public void setSiteName(String siteName) {
		this.siteName = siteName;
	}

	public String getSiteUrl() {
		return siteUrl;
	}

	public void setSiteUrl(String siteUrl) {
		this.siteUrl = siteUrl;
	}

	public String getWebMaster() {
		return webMaster;
	}

	public void setWebMaster(String webMaster) {
		this.webMaster = webMaster;
	}

	public String toString() {
		return "WebSite [siteName=" + siteName + ", siteUrl=" + siteUrl + ", webMaster=" + webMaster + "]";
	}

}

然后进行序列化和反序列化测试：

package cn.zifangsky.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 TestSerialize {

	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		TestSerialize.serializeWebSite();
		TestSerialize.deserializeWebSite();
	}
	
	/**
	 * 使用ObjectOutputStream 序列化WebSite
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 * 
	 * */
	public static void serializeWebSite() throws FileNotFoundException, IOException{
		WebSite webSite = new WebSite();
		webSite.setSiteName("zifangsky的个人博客");
		webSite.setSiteUrl("http://www.zifangsky.cn");
		webSite.setWebMaster("zifangsky");
		
		//序列化
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("C:/Users/Administrator/Desktop/test.txt")));
		objectOutputStream.writeObject(webSite);
		objectOutputStream.flush();
		objectOutputStream.close();
	}
	
	/**
	 * 使用ObjectInputStream 反序列化WebSite
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 * @throws ClassNotFoundException 
	 * 
	 * */
	public static void deserializeWebSite() throws FileNotFoundException, IOException, ClassNotFoundException{
		ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("C:/Users/Administrator/Desktop/test.txt")));
		//反序列化
		WebSite webSite = (WebSite) objectInputStream.readObject();
		objectInputStream.close();

		System.out.println(webSite);
	}
	
}

输出：

WebSite [siteName=zifangsky的个人博客, siteUrl=http://www.zifangsky.cn, webMaster=zifangsky]

四 使用Externalizable接口实现的实例

实现了Externalizable接口的实体类：

package cn.zifangsky.serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class ExternalizableDemo implements Externalizable{
	private String name;
	static {
		System.out.println("调用静态代码块");
	}

	public ExternalizableDemo() {
		System.out.println("调用无参构造方法");
	}

	public ExternalizableDemo(String name) {
		this.name = name;
		System.out.println("调用有参构造方法");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String toString() {
		return "ExternalizableDemo [name=" + name + "]";
	}
	
	/**
	 * ObjectOutputStream会调用writeExternal(ObjectOutput out))这个方法进行序列化
	 * */
	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeObject(name);
	}

	/**
	 * ObjectInputStream会调用readExternal(ObjectInput in)这个方法进行反序列化
	 * */
	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		name = (String) in.readObject();	
	}

}

然后进行序列化和反序列化测试：

package cn.zifangsky.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 TestExternalizable {

	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		ExternalizableDemo demo = new ExternalizableDemo("hello");
		// 序列化
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(
				new FileOutputStream(new File("C:/Users/Administrator/Desktop/test2.txt")));
		objectOutputStream.writeObject(demo);
		objectOutputStream.flush();
		objectOutputStream.close();
		
		//反序列化
		ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("C:/Users/Administrator/Desktop/test2.txt")));
		ExternalizableDemo demo2 = (ExternalizableDemo) objectInputStream.readObject();
		objectInputStream.close();
		System.out.println(demo2);		
	}

}

输出：

调用静态代码块
调用有参构造方法
调用无参构造方法
ExternalizableDemo [name=hello]

注：

（1）使用Externalizable进行序列化时，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中

（2）Externalizable接口继承自Serializable接口。两者的区别如下：

假设有一个Customer类的对象需要序列化，如果这个类仅仅实现了这个接口，那么序列化和反序列化的方式如下：ObjectOutputStream采用默认的序列化方式，对于这个类的非static，非transient的实例变量进行序列化，ObjectInputStream采用默认的反序列化方式，对于这个类的非static，非transient的实例变量进行反序列化。

如果这个类不仅实现了Serializable接口，而且定义了readObject（ObjectInputStream in）和 writeObject(ObjectOutputStream out)方法，那么将按照如下的方式进行序列化和反序列化：

ObjectOutputStream会调用这个类的writeObject方法进行序列化，

ObjectInputStream会调用相应的readObject方法进行反序列化。

实现Externalizable接口的类完全由自身来控制序列化的行为。而且必须实现writeExternal（ObjectOutput out）和readExternal（ObjectInput in）。那么将按照如下的方式进行序列化和反序列化：

ObjectOutputStream会调用这个类的writeExternal方法进行序列化，

ObjectInputStream会调用相应的readExternal方法进行反序列化。

PS：

如果想要进一步了解，可以参考这篇文章：http://www.blogjava.net/jiangshachina/archive/2012/02/13/369898.html

参考文章：

（1）http://www.cnblogs.com/xdp-gacl/p/3777987.html

（2）http://www.cnblogs.com/rollenholt/archive/2012/11/26/2789445.html

本文出自 “zifangsky的个人博客” 博客，请务必保留此出处http://983836259.blog.51cto.com/7311475/1758247