java对象的序列化和反序列化

转载自：http://www.cnblogs.com/xdp-gacl/p/3777987.html

把对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为对象的过程称为对象的反序列化。

为什么要进行对象的序列化？

在很多应用中，需要对某些对象进行序列化，存储在物理硬盘上，以便长期保存。比如WEB服务器中的对象session，当同时有十万个并发访问的话，内存不一定吃得消，Web容器会把一些session序列化到硬盘中，需要使用时，在把硬盘中的对象还原到内存。

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

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

java序列化有两种方法：实现Serializable接口或者实现Externalizable接口的类才能被序列化。本文主要介绍实现Serializable接口的序列化。

对象序列化步骤：

1、创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流。

2、通过对象输入流的readObject()方法读取对象。

对象反序列化步骤：

1、创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2、通过对象输入流readObject（）方法读取对象。

<span style="font-size:14px;">import java.io.Serializable;

public class Person implements Serializable{

	/**
	 * 序列化ID
	 */
//	private static final long serialVersionUID = -1606482416458361322L;
	private int age;
	private String name;
	private String sex;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
}</span>

<span style="font-size:14px;">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;
import java.text.MessageFormat;

public class TestObjSerializeAndDeserialize {
	//序列化
	private static void SerializePerson() throws FileNotFoundException,
			IOException{
		Person person = new Person();
		person.setName("Jack");
		person.setAge(25);
		person.setSex("男");
		
		ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
				new File("F:/Person.txt")));
		oo.writeObject(person);
		System.out.println("person对象序列化");
		oo.close();
	}
	//反序列化
	private static Person DeserializePerson() throws Exception,
			IOException{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
				new File("F:/Person.txt")));
		Person person = (Person)ois.readObject();
		System.out.println("Person对象序列化成功！");
		return person;
	}
	
	public static void main(String[] args) throws Exception{
		SerializePerson();//序列化
		Person p = DeserializePerson();//反序列化
		System.out.println(MessageFormat.format("name={0},age={1},sex={2}",p.getName(),
				p.getAge(),p.getSex()));
	}
}</span>

序列化Person成功后在E盘生成了一个Person.txt文件，而反序列化Person是读取E盘的Person.txt后生成了一个Person对象

serialVersionUID的作用

s​e​r​i​a​l​V​e​r​s​i​o​n​U​I​D​:​ ​字​面​意​思​上​是​序​列​化​的​版​本​号​，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量。

serialVersionUID有两种生成方式：1、生成的serialVersionUID是1L。

                                                               2、生成的serialVersionUID是根据类名，接口名，方法和属性等来生成的。

例：

<span style="font-size:14px;">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;
import java.io.Serializable;

public class TestSerialversionUID {

    public static void main(String[] args) throws Exception {
        SerializeCustomer();// 序列化Customer对象
        Customer customer = DeserializeCustomer();// 反序列Customer对象
        System.out.println(customer);
    }

    /**
     * MethodName: SerializeCustomer 
     * Description: 序列化Customer对象
     * @author xudp
     * @throws FileNotFoundException
     * @throws IOException
     */
    private static void SerializeCustomer() throws FileNotFoundException,
            IOException {
        Customer customer = new Customer("gacl",25);
        // ObjectOutputStream 对象输出流
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                new File("E:/Customer.txt")));
        oo.writeObject(customer);
        System.out.println("Customer对象序列化成功！");
        oo.close();
    }

    /**
     * MethodName: DeserializeCustomer 
     * Description: 反序列Customer对象
     * @author xudp
     * @return
     * @throws Exception
     * @throws IOException
     */
    private static Customer DeserializeCustomer() throws Exception, IOException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                new File("E:/Customer.txt")));
        Customer customer = (Customer) ois.readObject();
        System.out.println("Customer对象反序列化成功！");
        return customer;
    }
}

/**
 * <p>ClassName: Customer<p>
 * <p>Description: Customer实现了Serializable接口，可以被序列化<p>
 * @author xudp
 * @version 1.0 V
 * @createTime 2014-6-9 下午04:20:17
 */
class Customer implements Serializable {
    //Customer类中没有定义serialVersionUID
    private String name;
    private int age;

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /*
     * @MethodName toString
     * @Description 重写Object类的toString()方法
     * @author xudp
     * @return string
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "name=" + name + ", age=" + age;
    }
}</span>

我们在Customer中添加一个属性

class Customer implements Serializable {
    //Customer类中没有定义serialVersionUID
    private String name;
    private int age;
    <span style="color:#FF6666;">//新增属性
    private String sex;</span>
    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }

然后执行反序列化操作，抛出异常如下：

Exception in thread "main" java.io.InvalidClassException: Customer;
local class incompatible: 
stream classdesc serialVersionUID = -88175599799432325, 
local class serialVersionUID = -5182532647273106745

意思是说，文件流中的class和classpath中的Class，也就是修改之后的class，不兼容，处于安全机制考虑，程序抛出了错误，并且拒绝载入。此时应该怎么办呢？自己在Customer中指定一个serialVersionUID。在TestSerialversionUID中，没有指定Customer类的序列号，那么java编译器会自动给这个class进行一个摘要算法，类似于指纹算法，只要这个文件，多一个空格，得到的UID就会不一样截然不同，可以保证类的编号唯一，所以添加了一个字段后，没有指定serialVersionUID，编译器又为我们生成了一个UID，当然和前面保存在文件中的那个不会一样了，于是就出现了2个序列化版本号不一致的错误。因此，只要我们自己指定了serialVersionUID，就可以在序列化后，去添加一个字段，或者方法，而不会影响到后期的还原，还原后的对象照样可以使用，而且还多了方法或者属性可以用。

class Customer implements Serializable {<pre><span style="color:#ff0000;"><strong>   private static final long serialVersionUID = -5182532647273106745L;</strong></span>

 private String name; private int age; //新增属性  private String sex; public Customer(String name, int age) { this.name = name; this.age = age; }

在执行反序列化，ok