序列化与反序列化_序列化和反序列化小项目-CSDN博客

本文链接：https://blog.csdn.net/baidu_41922630/article/details/103062474

一、序列化与反序列化概念：

将对象转为字节序列的过程称为对象的序列化。
将字节序列转为对象的过程称为对象的反序列化。

作用：让对象离开内存空间，入住物理硬盘，以便长期保存。待它们被需要时反序列化在进入内存。比如：

常见的是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()方法读取对象。

三、序列化与反序列化例子以及其作用

1.写一个序列化对象与反序列化对象的类

package com.smy.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 SerializableAndDeSerializable {
	
	private static final String PATH = "F:\\Test\\temp.txt";
	
	public <T> void SerializableObject(T object) {
		File writeFile = new File(PATH);
		ObjectOutputStream oos;
		try {
			oos = new ObjectOutputStream(new FileOutputStream(writeFile));
			oos.writeObject(object);
			oos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	@SuppressWarnings("unchecked")
	public <T> T deSerializableTempObject() {
		File readFile = new File(PATH);
		T object = null;
		ObjectInputStream ois;
		try {
			ois = new ObjectInputStream(new FileInputStream(readFile));
			object = (T) ois.readObject();
			ois.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return object;
	}
}

2.给出一个类，其实例用来序列化（请大家注意序列号）

序列号通过计算是这样的

package com.smy.serializable;

import java.io.Serializable;

public class TempObject implements Serializable {
        //注意这个就是序列号
	private static final long serialVersionUID = -5024636473236758967L;

	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "TempObject [name=" + name + ", age=" + age + "]";
	}
}

3.给出序列化test

package com.smy.serializable;

public class Test {
	public static void main(String[] args) {
		TempObject object = new TempObject();
		object.setName("quanquan");
		object.setAge(12);
		
		SerializableAndDeSerializable serializable = new SerializableAndDeSerializable();
		System.out.println("序列化：" + object);
		serializable.SerializableObject(object);
	}
}

4.执行结果如下：

我们用UE打开它可以看到其2进制信息

我们可以清楚地发现序列号被写入了文件中。其中这个文件也写入了这个对象的信息，比如它的包名称、类名称、成员age（L代表为int）和name以及他们的值。

此时我们去反序列化：

package com.smy.serializable;

public class Test {
	public static void main(String[] args) {		SerializableAndDeSerializable serializable = new SerializableAndDeSerializable();
		TempObject obj = serializable.deSerializableTempObject();
		System.out.println("反序列化后：" + obj);
	}
}

发现可以成功的从文件中返还回原来的对象：

但还如果我们此时去改变TempObject类中的序列号会怎么样呢？

我们重新生成序列号 private static final long serialVersionUID = -4988341991316351459L;

这是我们再去执行反序列化：

可以看到发生了运行时异常，由此我们可以知道序列号的作用了：

作用：Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

补充： serialVersionUID 用来表明类的不同版本间的兼容性。

有两种生成方式：