Java的序列化和反序列化
概述
Java对象的序列化和反序列化，这个词对我来说追溯到大学阶段，学Java对象流时知道有这东西。老师告诉我们可以把Java对象化作字节流，储存文件或网络通信。然后就是巴啦巴拉，一脸懵逼。举个例子，有一台北京的Java虚拟机现在运行的某个对象要调用一台在长春运行的Java虚拟机内的某个对象，这是两个不同的Java虚拟机进程，我们没办法直接传递对象的引用，现在我们只能把长春的这个对象序列化，变成一块一块碎片，传给北京的虚拟机，北京虚拟机反序列化后就造出了一个对象，然后就可以正常使用。说得通俗点，这个序列化就是跨进程数据传输。
序列化（Serializable接口）
要序列化的类通过实现java.io.Serializable接口启动序列化的功能，如果它有子类，所有的子类本身也都可序列化。
Person类
public class Person implements Serializable
{
private String name; private int age; private String sex; public Person(String name,int age,String sex)
{
this.name = name;
this.age = age;
this.sex = sex;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex;
}
}
serializable接口没有函数或者字段，我们可以看到我们implements接口，没实现任何的函数，它仅仅用于标识可序列化，如果我们没有实现这个标识接口而进行序列化，会抛出一个NotSerializableException异常。
Main类
public class Main
{ public static void main(String[] args)
{
serializePerson();
} private static void serializePerson()
{
try {
Person customer = new Person("张三",15,"男");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("E:/Person"));
objectOutputStream.writeObject(customer);
System.out.println("Person序列化完成。。。");
objectOutputStream.close();
}catch (Exception e){
e.printStackTrace();
System.out.println("Person序列化出错。。。");
}
}
}
输出
Person序列化完成。。
在 E盘下就会有一个Person文件，用notepad++打开，依稀可以见到一些熟悉的字眼
我们用二进制查看器打开这个文件
左边第一个部分是序列化的文件头AC ED 00 05,其他还有关于序列化的类描述，里面的各个属性值，还有父类的信息，lz实在看不懂了，有大佬分析过序列化文件，有兴趣可自行百度查看。
反序列化
Main类添加DeserializePerson函数
private static Object DeserializePerson()
{
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(new File("E:/Person")));
Object object = objectInputStream.readObject();
System.out.println("反序列化完成。。。");
return object;
} catch (Exception e)
{
e.printStackTrace();
}finally
{
if (objectInputStream != null )
{
try
{
objectInputStream.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
return null;
}
输出
反序列化完成。。。
姓名:张三,年龄:15,性别:男
serialVersionUID（标识）
知道serializable是标识的语义，这个标识是在哪？如果我们没特意指定，在编译过程中Java编译器会默认赋予它一个独一无二的编号，保证它是唯一的。但这样做是否会给我们带来影响？
Person类
public class Person implements Serializable
{ private String name; private int age; private String sex;
//添加了一个属性
private String number; public Person(String name,int age,String sex)
{
this.name = name;
this.age = age;
this.sex = sex;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex;
}
}
Main类
public class Main
{ public static void main(String[] args)
{
//serializePerson();
Person person = (Person) DeserializePerson();
System.out.println(person);
} private static Object DeserializePerson()
{
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(new File("E:/Person")));
Object object = objectInputStream.readObject();
System.out.println("反序列化完成。。。");
return object;
} catch (Exception e)
{
e.printStackTrace();
}finally
{
if (objectInputStream != null )
{
try
{
objectInputStream.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
return null;
} private static void serializePerson()
{
try {
Person customer = new Person("张三",15,"男");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("E:/Person"));
objectOutputStream.writeObject(customer);
System.out.println("Person序列化完成。。。");
objectOutputStream.close();
}catch (Exception e){
e.printStackTrace();
System.out.println("Person序列化出错。。。");
}
}
}
发现抛出了一个异常
本地的文件流中的class（序列化）和修改完的Person.class，不兼容了（UID），处于安全机制考虑，程序抛出错误，拒绝载入。如何保证UID版本一致，那只能自己指定UID，在序列化后，去添加字段或者函数，就不会影响后期还原。
Person类
public class Person implements Serializable
{ private static final long serialVersionUID = 55555L; private String name; private int age; private String sex; public Person(String name,int age,String sex)
{
this.name = name;
this.age = age;
this.sex = sex;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex;
}
}
Main类
public class Main
{ public static void main(String[] args)
{
serializePerson();
Person person = (Person) DeserializePerson();
System.out.println(person);
} private static Object DeserializePerson()
{
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(new File("E:/Person")));
Object object = objectInputStream.readObject();
System.out.println("反序列化完成。。。");
return object;
} catch (Exception e)
{
e.printStackTrace();
}finally
{
if (objectInputStream != null )
{
try
{
objectInputStream.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
return null;
} private static void serializePerson()
{
try {
Person customer = new Person("张三",15,"男");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("E:/Person"));
objectOutputStream.writeObject(customer);
System.out.println("Person序列化完成。。。");
objectOutputStream.close();
}catch (Exception e){
e.printStackTrace();
System.out.println("Person序列化出错。。。");
}
}
}
序列化后，我们注释掉main函数里的serializePerson()；修改Person类，添加或修改字段，进行反序列化。
反序列化完成。。。
姓名:张三,年龄:15,性别:男
我们可以发现，由编译器默认自动给我们生成的UID编码，并不可控，对同一个类，A编译器编译，赋予一个UID的值和B编译器编译赋予的UID值也有可能不同，所以为了提高可控性，确定性，我们在一个可序列化的类中应该明确为它赋值。
Externalizable接口
以上我们可以发现，所有的序列化操作都是默认的，自动帮我们完成。但有时我们并不想这样，有些属性我们并不想序列化，想要自定义的方式去序列化它。为此，Java提供了一个Externalizable接口，方便用户自定义序列化过程，它和Serializable有什么区别？
Person类
public class Person implements Externalizable
{ private static final long serialVersionUID = 55555L; private String name; private int age; private String sex; public Person()
{ } public Person(String name,int age,String sex)
{
this.name = name;
this.age = age;
this.sex = sex;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex;
} @Override
public void writeExternal(ObjectOutput out) throws IOException
{ } @Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{ }
}
Main类不变，输出
Person序列化完成。。。
反序列化完成。。。
姓名:null,年龄:0,性别:null
与serialization接口相比，我们很快就能看出，Externalizable接口对Person类进行序列化和反序列化之后得到的对象的状态并没有保存下来，所有属性的值都变成默认值。它们之间有什么关系和区别？
- Externalizable继承了Serializable，它定义了两个抽象函数，writeExternal和readExternal，我们进行序列化和反序列需要重写，可以指定序列化哪些属性。
- Externalizable序列化的类必须有一个无参构造函数，否则会报错。因为Externalizable序列化的时候，读取对象时，会调用无参构造函数创建一个新的对象，之后将保存对象的字段的值填充到新对象中。
修改Person类，重新序列化
@Override
public void writeExternal(ObjectOutput out) throws IOException
{
out.writeObject(name);
out.writeObject(age);
out.writeObject(sex);
} @Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
this.name = (String)in.readObject();
this.age = (int)in.readObject();
this.sex = (String)in.readObject();
}
输出
Person序列化完成。。。
反序列化完成。。。
姓名:张三,年龄:15,性别:男
重写完两个函数，发现对象持久化完成。但细心的小伙伴可能会发现，我们序列化的成员变量都是实例变量。就会有一个疑问，换成静态变量试试？
静态变量被序列化？
其实序列化（默认序列化）被不保存静态变量，因为静态变量属于类本身，对象序列化，顾名思义就是指的对象本身状态，并不包含静态变量。
public class Person implements Serializable
{
private static final long serialVersionUID = 55555L; private String name; private int age; private String sex; private static String money; public Person(String name,int age,String sex,String money)
{
this.name = name;
this.age = age;
this.sex = sex;
this.money = money;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex + ",资产:" + money;
} }
Main类
public class Main {
public static void main(String[] args) throws Exception {
serializablePerson();
Person person = (Person)DeserializablePerson();
System.out.println(person);
}
//演示使用，并不规范
private static void serializablePerson() throws Exception {
Person person = new Person("张三",15,"男","5000000");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/Person"));
objectOutputStream.writeObject(person);
objectOutputStream.close();
System.out.println("序列化完成。。。");
}
private static Object DeserializablePerson() throws Exception
{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("D:/Person")));
Object object = objectInputStream.readObject();
objectInputStream.close();
System.out.println("反序列完成。。。");
return object;
}
}
输出
序列化完成。。。
反序列完成。。。
姓名:张三,年龄:15,性别:男,资产:5000000
结果跟我们的结论出乎意料，静态变量被序列化了，真的是这样吗？导致这个原因是因为我们测试都是在一个进程里面的。JVM把money这个变量加载进来了，所以导致我们看到的是加载过的money。我们可以这样做，多写一个Main类，让JVM退出后，重新加载。
MainTest类
public class MainTest {
public static void main(String[] args) throws Exception {
Person person = (Person)DeserializablePerson();
System.out.println(person);
}
private static Object DeserializablePerson() throws Exception
{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("D:/Person")));
Object object = objectInputStream.readObject();
objectInputStream.close();
System.out.println("反序列化完成。。。");
return object;
}
}
现在先运行Main类，得到的是我们上面的接口，现在运行MainTest类
反序列化完成。。。
姓名:张三,年龄:15,性别:男,资产:null
可以发现静态成员变量并没有被保存下来，变成一个默认值。
transient关键字（默认序列化）
有时候我们并不想自定义序列化，然而有些成员变量我们也不想序列化。那么transient这个关键字就是你的不二人选，它的作用很简单，就是控制变量的序列化，在变量声明前加上这个关键字即可。
Person类
public class Person implements Serializable
{
private static final long serialVersionUID = 55555L; private String name; private int age; private String sex; private static String money;
//银行账户
private transient String bankNumber;
//银行密码
private transient int passWord; public Person(String name,int age,String sex,String money,String bankNumber,int passWord)
{
this.name = name;
this.age = age;
this.sex = sex;
this.money = money;
this.bankNumber = bankNumber;
this.passWord = passWord;
} public int getAge()
{
return age;
} public String getName()
{
return name;
} public String getSex()
{
return sex;
} @Override
public String toString()
{
return "姓名:" + this.name + ",年龄:" + this.age + ",性别:" + this.sex + ",资产:" + money + "，我的银行账户是:" + this.bankNumber + ",我的银行密码:" + this.passWord;
} }
Main类
public class Main {
public static void main(String[] args) throws Exception {
serializablePerson();
Person person = (Person)DeserializablePerson();
System.out.println(person);
}
//演示使用，并不规范
private static void serializablePerson() throws Exception {
Person person = new Person("张三",15,"男","5000000","564654979797464646",123456);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/Person"));
objectOutputStream.writeObject(person);
objectOutputStream.close();
System.out.println("序列化完成。。。");
}
private static Object DeserializablePerson() throws Exception
{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("D:/Person")));
Object object = objectInputStream.readObject();
objectInputStream.close();
System.out.println("反序列完成。。。");
return object;
}
}
输出
序列化完成。。。
反序列完成。。。
姓名:张三,年龄:15,性别:男,资产:5000000，我的银行账户是:null,我的银行密码:0
这些关键信息就都不会被序列化到文件中，当然我有500w的话
序列化的存储规则
Java序列化为了节省存储空间，有特定的存储规则，写入文件为同一对象的时候，并不会再将对象的内容存储，而只是再次存储一份引用。
Main类
public class Main {
public static void main(String[] args) throws Exception {
serializablePerson();
Person person = (Person) DeserializablePerson();
System.out.println(person);
}
//演示使用，并不规范
private static void serializablePerson() throws Exception {
Person person = new Person("张三",15,"男","5000000","564654979797464646",123456);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/Person"));
objectOutputStream.writeObject(person);
objectOutputStream.flush();
System.out.println(new File("D:/Person").length());
objectOutputStream.writeObject(person);
objectOutputStream.close();
System.out.println(new File("D:/Person").length());
System.out.println("序列化完成。。。");
}
private static Object DeserializablePerson() throws Exception
{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("D:/Person")));
Person person =(Person) objectInputStream.readObject();
Person person1 =(Person) objectInputStream.readObject();
objectInputStream.close();
System.out.println("反序列完成。。。");
System.out.print("是否同一个对象=====>");
System.out.println(person == person1);
return person;
}
}
输出
108
113
序列化完成。。。
反序列完成。。。
是否同一个对象=====>true
姓名:张三,年龄:15,性别:男,资产:5000000，我的银行账户是:null,我的银行密码:0
多出五字节存储空间就是新增引用和一些控制信息空间，反序列时，恢复引用关系，person和person1都指向唯一的对象，二者相等，输出true，这样的存储规则就极大节省了存储的空间。
注意事项
可以发现，我很多地方加了默认序列化的情况下，如果是自定义序列化，那么transient这些就统统无效，是不是感觉可控性增强不少，序列化还得注意几个点。
- 如果有内部类，或者是要序列化的对象的成员变量是一个对象类，那么也必须继承序列化的接口，否则会出错滴。
- 子类即使没有实现序列化的接口，只要父类实现了，那子类就可以直接序列化。
参考:Java序列化的高级认识
===============================================================
如发现错误，请及时留言，lz及时修改，避免误导后来者。感谢！！！
Java的序列化和反序列化的更多相关文章
- java 对象序列化与反序列化
Java序列化与反序列化是什么? 为什么需要序列化与反序列化? 如何实现Java序列化与反序列化? 本文围绕这些问题进行了探讨. 1.Java序列化与反序列化 Java序列化是指把Java对象转换为 ...
- Java对象序列化与反序列化一 JSON
Java对象序列化与反序列化一 JSON 1. 依赖库 jackson-all-1.6.1.jar 2. 代码 public class Student { private String nam ...
- Java对象序列化和反序列化的工具方法
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import ja ...
- Java之序列化和反序列化
序列化的对象: package test_demo.SerializableOper; import java.io.Serializable; /* * 序列化对象需要实现序列号接口 * */ pu ...
- java之序列化与反序列化
1.这里主要是介绍Protobuf提供的序列化与反序列化的高效性.相对于传统的java提供的序列化来说,Protobuf的效率提高了很多倍.但是也有不足的地方,就是proto在对象序列化的时候抛弃了很 ...
- Java基础—序列化与反序列化（转载）
转载自: Java序列化与反序列化 1.Java序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程:而Java反序列化是指把字节序列恢复为Java对象的过程. 2.为什么需要序列化 ...
- Java 中序列化与反序列化
一. 序列化和反序列化概念 Serialization(序列化)是一种将对象以一连串的字节描述的过程:反序列化deserialization是一种将这些字节重建成一个对象的过程.将程序中的对象,放入文 ...
- JAVA的序列化与反序列化
一.为什么要进行序列化 再介绍之前,我们有必要先了解下对象的生命周期,我们知道Java对象的生命周期,也即Java中的远程方法调用RMI也会被用到,在网络中要传输对象的话,则必须要对对象进行序列化,关 ...
- 深入分析Java的序列化与反序列化
序列化是一种对象持久化的手段.普遍应用在网络传输.RMI等场景中.本文通过分析ArrayList的序列化来介绍Java序列化的相关内容.主要涉及到以下几个问题: 怎么实现Java的序列化 为什么实现了 ...
- Java 对象序列化和反序列化
之前的文章中我们介绍过有关字节流字符流的使用,当时我们对于将一个对象输出到流中的操作,使用DataOutputStream流将该对象中的每个属性值逐个输出到流中,读出时相反.在我们看来这种行 ...
随机推荐
- OO，OO以后，及其极限
1.什么是软件开发? 软件开发的过程就是人们使用各种计算机语言将人们关心的现实世界映射到计算机世界的过程: 现在的计算机的数学理论基础是由计算机的开山鼻祖,大名鼎鼎的图灵于1937年提出的图灵机模型. ...
- Error:unsupported class file version 52.0问题的解决
这个问题主要的原因是依赖包的编译版本比主程序的编译版本高,导致主程序无法正常编译或运行,解决这个问题无非两招: 1.提升主程序的编译器版本,用最新的编译器编译主程序,这样就可以兼容那个依赖包 2.降低 ...
- Java永久代去哪儿了
http://www.infoq.com/cn/articles/Java-PERMGEN-Removed 在Java虚拟机(以下简称JVM)中,类包含其对应的元数据,比如类的层级信息,方法数据和方法 ...
- 从 <sofa:XXX> 标签开始看 SOFA-Boot 如何融入 Spring
前言 SOFA-Boot 现阶段支持 XML 的方式在 Spring 中定义 Bean,通过这些标签,我们就能从 Spring 容器中取出 RPC 中的引用,并进行调用,那么他是如何处理这些自定义标签 ...
- 如何优雅的关闭Java线程池
面试中经常会问到,创建一个线程池需要哪些参数啊,线程池的工作原理啊,却很少会问到线程池如何安全关闭的. 也正是因为大家不是很关注这块,即便是工作三四年的人,也会有因为线程池关闭不合理,导致应用无法正常 ...
- SpringBoot cache-control 配置静态资源缓存 （以及其中的思考经历）
昨天在部署项目时遇到一个问题,因为服务要部署到外网使用,中间经过了较多的网络传输限制,而且要加载arcgis等较大的文件,所以在部署后,发现页面loading需要很长时间,而且刷新也要重新从服务器下载 ...
- vue 使用踩坑 note
1. 如图,假如large那一行错写成 'large': item.ext_data.isLarge + '' === 'true',, 那么,编译不报错,控制台无提示,模板不输出. 2. vue的t ...
- SSM-SpringMVC-04：SpringMVC深入浅出理解HandleMapping（源码刨析）
------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 先从概念理解,从中央调度器,携带参数request,调度到HandleMapping处理器映射器,处理器映射器 ...
- Open-Source Service Discovery
Service discovery is a key component of most distributed systems and service oriented architectures. ...
- 使用Ratpack与Spring Boot构建高性能JVM微服务
在微服务天堂中Ratpack和Spring Boot是天造地设的一对.它们都是以开发者为中心的运行于JVM之上的web框架,侧重于生产率.效率以及轻量级部署.他们在服务程序的开发中带来了各自的好处.R ...