序列化与反序列化的简单示例

1. 编写可序列化的实体：

package com.huey.entity;

import java.io.Serializable;

/**
 * Book，实现了Serializable接口，表示该类的对象可序列化
 * @version 2013-08-03
 * @author huey2672
 *
 */
public class Book implements Serializable {
	
	/**
	 * 序列化ID
	 */
	private static final long serialVersionUID = 1483603838392146643L;

	// 需要注意的是，所有的属性也必须是可序列化的
	private String name;
	private String isbn;
	private String author;
	private double price;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}

	public String getIsbn() {
		return isbn;
	}

	public void setIsbn(String isbn) {
		this.isbn = isbn;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}
	
	public Book() {
	}
	
	public Book(String name, String isbn, String author, double price) {
		setName(name);
		setIsbn(isbn);
		setAuthor(author);
		setPrice(price);
	}
	
	@Override
	public String toString() {
		if (this == null) {
			return super.toString();
		} else {
			return String.format("[%s, %s, %s, ￥%.2f]", name, isbn, author, price);
		}
	}
}

2. 序列化工具类：

package com.huey.serialization;

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

import com.huey.entity.Book;

/**
 * 序列化与反序列化工具类
 * @version 2013-08-03
 * @author huey2672
 *
 */
public class SerializationUtil {

	/**
	 * 序列化Book对象
	 * @param book		要序列化的Book对象
	 * @param filePath	存储序列化对象的文件
	 */
	public void serializeBook(Book book, String filePath) {		
		try {
			// 获得文件输出流
			FileOutputStream fos = new FileOutputStream(filePath);
			// 获得对象输出流
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			// 序列化对象
			oos.writeObject(book);
			// 关闭流
			fos.close();
			oos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 反序列化Book对象
	 * @param filePath	存储序列化对象的文件
	 * @return			反序列化后得到的Book对象
	 */
	public Book deserializeBook(String filePath) {
		Book book = null;
		try {
			// 获得文件输入流
			FileInputStream fis = new FileInputStream(filePath);
			// 获得对象输入流
			ObjectInputStream ois = new ObjectInputStream(fis);
			// 反序列化得到对象
			book = (Book)ois.readObject();
			// 关闭流
			ois.close();
			fis.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return book;
	}

}

3. 测试用例：

package com.huey.test;

import org.junit.Test;

import com.huey.entity.Book;
import com.huey.serialization.SerializationUtil;

/**
 * 序列化与反序列化测试用例
 * @version 2013-08-03
 * @author huey2672
 *
 */
public class SerializationTest {

	/**
	 * 测试序列化
	 */
	@Test
	public void testSerialization() {
		String filePath = "book.ser";
		Book book = new Book("编程之美", "978-7-121-06074-8", "编程之美小组", 40.00);
		
		SerializationUtil serializationUtil = new SerializationUtil();
		serializationUtil.serializeBook(book, filePath);
	}
	
	/**
	 * 测试反序列化
	 */
	@Test
	public void testDeserialization() {
		String filePath = "book.ser";
		Book book = null;
		SerializationUtil serializationUtil = new SerializationUtil();
		book = serializationUtil.deserializeBook(filePath);
		System.out.println(book);
	}
}

4. 一些要点：

1) 对象必须实现Serializable接口才能被序列化；

2) 如果父类是可序列化的，则其子类也是可序列化的；

3) 如果类中的属性是引用数据类型，则该属性也必须是可序列化的；

4) 如果实例变量被transient修饰，则该实例变量不会被实例化，该变量在还原时会被赋予null或基本数据类型的默认值。

5) 静态变量不会被序列化。