java对象序列化和反序列化操作记录

日期： 2016-6-30

内容：

1、java对象的序列化；

2、java对象的反序列化；

在昨天看了以为博主的博客讲到java中的序列化和反序列化在开发中的重要性，感觉挺重要，在经过自己的加工之后总结如下：

一， 概念剖析：

把对象转换成字节序列的过程称之为对象的序列化；

把字节学历恢复为对象的过程称之为对象的饭序列化；

  

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

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

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

二、JDK类库中的序列化API

　　java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
　　java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
　　只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。
　　对象序列化包括如下步骤：
　　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
　　2） 通过对象输出流的writeObject()方法写对象。

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

对象序列化和反序列范例：

package com.javabasic.serializabledemo;

import java.io.Serializable;

//import javax.annotation.Resource;

//这个Person类用于测试对象序列化和反序列化
//@Resource()//证明这是一个Bean
public class Person implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	//年龄
	private int age;
	
	//姓名
	private String username;
	
	//性别
	private String sex;

	
	//生成对应的getter和setter
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
	//生成一个不带参数的构造函数
	public Person()
	{
		
	}

	@Override
	public String toString() {
		return "Person [age=" + age + ", username=" + username + ", sex=" + sex
				+ "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((sex == null) ? 0 : sex.hashCode());
		result = prime * result
				+ ((username == null) ? 0 : username.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (sex == null) {
			if (other.sex != null)
				return false;
		} else if (!sex.equals(other.sex))
			return false;
		if (username == null) {
			if (other.username != null)
				return false;
		} else if (!username.equals(other.username))
			return false;
		return true;
	}
}

序列化和反序列化Person类对象：

接口设计： SerialiableInterface.java

package com.javabasic.serializableInterface;

import java.io.File;

import com.javabasic.serializabledemo.Person;

public interface SerialiableInterface {

	//编写实现序列化的方法
	public void objectSerializable(Object obj);
	
	//反序列化方法
	public Person deObjectSerializable(File file);
}

接口的实现： 

<strong><span style="color:#3366ff;">ObjSerializeAndDeserialize.java</span></strong>

package com.javabasic.serializabledemo;

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 com.javabasic.serializableInterface.SerialiableInterface;

public class ObjSerializeAndDeserialize implements SerialiableInterface{

	/**
	 * 实现对象的序列化和反序列化
	 */
	//编写对象序列化的方法
	@Override
	public void objectSerializable(Object obj)
	{
		try{
			//获得ObjectOutPutStrean对象输出流，将对象保存在物理介质(硬盘上)
			@SuppressWarnings("resource")
			ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(new File("C:/Person.txt")));
			
			//将对象写入磁盘
			oo.writeObject(obj);
			//打印提示信息
			System.out.println("对象序列化成功！");
		}
		catch(FileNotFoundException ex)
		{
			//打印异常堆栈
			ex.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public Person deObjectSerializable(File file) {
		
		Person person = null;
		//获得反序列化的对象
		try {
			//实现反序列化
			@SuppressWarnings("resource")
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
			
			person = (Person)ois.readObject();
			System.out.println(person);
			System.out.println("反序列化成功！");
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} catch (IOException e) {
			
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		return person;
	}
}

测试类编写： 

<strong><span style="color:#3366ff;">testObjectSerializable.java</span></strong>

package com.javabasic.serializabledemo;

import java.io.File;

import org.junit.Test;

public class testObjectSerializable {

	//对象序列化测试
	@Test
	public void testObjectSerializable()
	{
		//初始化一个Person对象
		Person p1 = new Person();
		p1.setAge(23);
		p1.setSex("男");
		p1.setUsername("吴彦组");
		
		//获得序列化函数实例
		ObjSerializeAndDeserialize os = new ObjSerializeAndDeserialize();
		
		//调用序列化方法
		os.objectSerializable(p1);
	}
	
	//测试对象的反序列化
	@Test
	public void testDeSerializable()
	{
		//创建一个File对象
		File file = new File("C:/Person.txt");
		
		//创建反序列化对象
		ObjSerializeAndDeserialize os = new ObjSerializeAndDeserialize();
		
		//调用反序列化函数
		os.deObjectSerializable(file);
	}
}