是时候放弃 Java 序列化了

基本概念

Java 序列化和反序列化三连问：

  • 什么是 Java 序列化和反序列化？
  • 为什么需要 Java 序列化和反序列化？
  • 如何实现 Java 序列化和反序列化？

是什么

一句话就能够说明白什么是 Java 序列化和反序列化？Java 序列化是将 Java 对象转换为字节序列的过程，而 Java 反序列化则是将字节序列恢复为 Java 对象的过程。

  • 序列化：任何需要保存到磁盘或者在网络进行传输的 Java 对象都需要支持序列化，序列化后的字节流保存了 Java 对象的状态及相关的描述信息，反序列化能够根据这些信息“复刻”出一个一模一样的对象。序列化的核心作用就是对象状态的保存。
  • 反序列化：反序列化就是根据磁盘中保存的或者网络上传输的字节流中所保存的对象状态和相关描述信息，通过反序列化重建对象。

所以，从本质上来说，序列化就是将对象的状态和相关描述信息按照一定的格式写入到字节流中，而反序列化则是从字节流中重建这个对象。

为什么

为什么需要 Java 序列化和反序列化呢？有两个原因：

  1. 持久化。即将该对象保存到磁盘中。一般来说我们是不需要持久化 Java 对象的，但是如果遇到特殊情况，我们需要将 Java 对象持久化到磁盘中，以便于我们在重启 JVM 时可以重建这些 Java 对象。所以我们可以通过序列化的方式将 Java 对象转换成字节流，然后将这些字节流保存到磁盘中实现持久化。在我们应用程序重启时，可以读取这些字节流进行反序列化还原 Java 对象。
  2. 网络传输：我们都知道网络上传输的对象是二进制字节流，我们是无法传输一个 Java 对象给一个应用的，所以在传输前我们需要对 Java 对象进行序列化将其转换为字节流。而接收方则根据字节流中所包含的信息重建该 Java 对象。

怎么做？

在 Java 中，如果一个对象要想实现序列化，它有两种方式：

  1. 实现 Serializable 接口
  2. 实现 Externalizable 接口

这两个接口是如何工作的呢？又有什么区别呢？下面我们分别介绍。

Java 如何实现序列化和反序列化

Serializable 接口

Serializable 接口只是一个标记接口，不用实现任何方法。一个对象只要实现了该接口，就意味着该对象是可序列化的。

序列化

Java 对象序列化的步骤如下：

  1. 对象实现 Serializable 接口
  2. 创建一个 ObjectOutputStream 输出流
  3. 调用 ObjectOutputStream 对象的 writeObject() 输出可序列化对象

如下：

@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {private String name;private Integer age;private Float height;
}public class Serializable01 {public static void main(String[] args) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person01.txt"));Person person01 = new Person("张三",35,175.4F);oos.writeObject(person01);}
}

用 idea 打开 person01.txt 文件就可以得到如下内容：

从这个文件中我们基本上可以看清楚 Person01 对象的字节流的轮廓。

反序列化

Java 反序列化步骤如下：

  1. 对象实现 Serializable 接口
  2. 创建一个 ObjectInputStream 对象
  3. 调用 ObjectInputStream 对象的 readObject()
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person01.txt"));
Person person011 = (Person01) ois.readObject();
System.out.println("person01.txt 反序列化内容：" + person011.toString());

运行结果

person01.txt 反序列化内容：Person01(name=张三, age=35, height=175.4)

反序列化生成的对象和序列化的对象内容一模一样，完全还原了序列化时的对象。

成员为引用的序列化

上面的例子 Person 的成员变量都是基本类型，如果成员变量为引用类型呢？

我们去掉 Person 类实现的 Serializable 接口，然后定义一个 Women 类。

public class Person {private String name;private Integer age;private Float height;
}public class Woman implements Serializable {private String hairColor;private Person person;
}

我们再来序列化 Woman 这类

public class Serializable02 {public static void main(String[] args) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("woman.txt"));Person person = new Person("李四",30,180F);Woman woman = new Woman("黄颜色",person);oos.writeObject(woman);}
}

执行时，你会发现程序会抛出异常：

java.io.NotSerializableException: com.sike.javacore.serializer.serializable.dto.Person
...

所以，一个可序列化的类，如果它含有引用类型的成员变量，那么这个引用类型也必须是可序列化的。

自定义序列化

有些时候我们并不需要将一个对象的所有属性全部序列化，这个时候我们可以使用 transient 关键字来选择不需要序列化的字段。

transient** 的作用就是用来标识一个成员变量在序列化应该被忽略。**

public class Person_1 implements Serializable {private String name;// 标识为 transientprivate transient Integer age;private Float height;
}

将 age 属性标识为 transient。

public class Serializable03 {public static void main(String[] args) throws Exception {// 先序列化ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person_1.txt"));Person_1 person = new Person_1("王五",32,180F);oos.writeObject(person);System.out.println("原对象：" + person);// 再反序列化ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person_1.txt"));Person_1 person1 = (Person_1) ois.readObject();System.out.println("序列化后对象：" + person1);}
}

运行结果：

原对象：Person_1(name=王五, age=32, height=180.0)
序列化后对象：Person_1(name=王五, age=null, height=180.0)

从运行结果我们可以看出，用 transient 标识的属性，在进行序列化时会将该字段忽略，然后在反序列化的时候，被 transient 标识的属性会被设置为默认值。

Externalizable 接口

一个类除了实现 Serializable 接口外来实现序列化，还有一种更加灵活的方式来实现序列化：实现 Externalizable 接口。

Externalizable 接口是 Serializable 的子类，它提供了 writeExternal() 和 readExternal() 方法让类能够更加灵活地实现序列化。

public interface Externalizable extends java.io.Serializable {void writeExternal(ObjectOutput out) throws IOException;void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

一个类如果实现了 Externalizable 接口，即必须要实现 writeExternal() 和 readExternal() 两个方法。在这两个方法里面你可以做自己任何想做的事情。

public class Student implements Externalizable {private String name;private int age;private int grade;@Overridepublic void writeExternal(ObjectOutput out) throws IOException {out.writeObject(name);out.writeInt(age - 2);      // 年龄我虚报 2 岁// 成绩我不报了}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {this.name = (String) in.readObject();this.age = in.readInt();}
}public class Serializable04 {public static void main(String[] args) throws Exception {// 先序列化ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.txt"));Student student = new Student("小明",15,55);oos.writeObject(student);System.out.println("序列化对象内容：" + student);ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.txt"));Student student1 = (Student) ois.readObject();System.out.println("序列化后的内容：" + student1);}
}

运行结果：

序列化对象内容：Student(name=小明, age=15, grade=55)
序列化后的内容：Student(name=小明, age=13, grade=0)

根据运行结果我们看到，Externalizable 接口可以实现自定义的序列化和反序列化。

但是使用 Externalizable 接口时要注意，writeExternal() 方法和 readExternal() 的顺序要一致，即 writeExternal() 是按照怎么样的顺序来 write 值的，readExternal() 就必须严格按照这个顺序来 read ，否则会报错。有兴趣的小伙伴可以 name 和 age 的顺序调整下，就知道了。

Serializable 和 Externalizable 对比

serializableExternalizable
系统自动存储 Java 对象必要的信息程序员自己来实现 Java 对象的序列化，灵活度更加高
不需要的属性使用 transient 修饰不需要的属性可以不写入对象
在反序列化的时候不走构造方法反序列化时，先走无参构造方法得到一个空对象，在调用 readExternal() 方法来读取序列化文件中的内容给该空对象赋值

serialVersionUID 版本号

我们先看一个例子。

我们先将 Student 对象序列化到本地磁盘 student.txt 文件中，然后在 Student 类里面增加一个字段，比如 className，用来表示所在的班级，然后再用刚刚已经序列化的 student.txt 来反序列化试图还原 Student 对象，这个时候你会发现运行报错，抛出下面的异常：

Exception in thread "main" java.io.InvalidClassException: com.sike.javacore.serializer.serializable.dto.Student; local class incompatible: stream classdesc serialVersionUID = -1065600830313514941, local class serialVersionUID = 2126309100823681

异常信息说明：序列化前后的 serialVersionUID 不一致。一个是 serialVersionUID = -1065600830313514941，另外一个是 serialVersionUID = 2126309100823681。

为什么两个 serialVersionUID 会不一样呢？因为我们对 Student 类做了变更，即所谓的升级。

在我们实际开发中，我们的 Class 文件不可能一成不变，它是随着项目的升级，Class 文件也会 升级，但是我们不能因为升级了 Class 类就导致之前的序列化对象无法还原了，我们需要做到升级前后的兼容性。怎么保证呢？显示声明 serialVersionUID。

Java 序列化提供了一个 private static final long serialVersionUID = xxxx 的序列化版本号，只要版本号相同，就可以将原来的序列化对象还原。

类的序列化版本号 serialVersionUID 可以随意指定，如果不指定，则 JVM 会根据类信息自己生成一个版本号，但是这样就会无法保证类升级后的序列化了。同时，不指定版本号也不利于 JVM 间的移植，因为可能不同的 JVM 版本计算规则可能就不一样了，这样也会导致无法反序列化。所以，凡是实现 Serializable 接口的类，我们都需要显示声明一个 serialVersionUID 版本号。

缺点

说实在话，现在几乎不会有人使用 Java 原生的序列化了，有如下几个原因使得我们不得不嫌弃他。

无法跨语言

通过 Java 原生 Serializable 接口与 ObjectOutputStream 实现的序列化，只能通过 Java 语言自己的ObjectInputStream 来反序列化，其他语言，如 C、Python、Go 等等都无法对其进行反序列化，这不很坑么？

同时，跨平台支持也不是很好，客户端与服务端如果因为 JDK 的版本不同都有可能导致无法进行反序列化，这个就更加坑了。

序列化字节流太大

Java 序列化它需要将类的描述信息和属性进行序列化，如果不这样做，它根本无法还原，这就会导致序列化字节流变得很大。我们来做一个比较，一个是 Java 原生序列化，一个是通用的二进制编码。

public class UserInfo implements Serializable {private static final long serialVersionUID = 1L;private Long id;private String userName;private String nickName;public byte[] codeC() {ByteBuffer buffer = ByteBuffer.allocate(1024);byte[] userNameBytes = this.userName.getBytes();buffer.putInt(userNameBytes.length);buffer.put(userNameBytes);byte[] nickNameBytes = this.nickName.getBytes();buffer.putInt(nickNameBytes.length);buffer.put(nickNameBytes);buffer.putLong(this.id);buffer.flip();byte[] result = new byte[buffer.remaining()];buffer.get(result);return result;}
}

UserInfo 类有一个 codeC() 方法，该方法返回 UserInfo 的字节流。

public class Serializable01 {public static void main(String[] args) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person01.txt"));Person person01 = new Person("张三",35,175.4F);oos.writeObject(person01);oos.close();ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person01.txt"));Person person011 = (Person) ois.readObject();System.out.println("person01.txt 反序列化内容：" + person011.toString());}
}

运行结果：

原生 JDK 序列化生成的字节流大小：246
UserInfo 对象字节流大小：31

有 8 倍的差距，这差距还是有点儿大的。

序列化时间太长

还是上面那个类，我们把上面的程序改下：

public class Serializable05 {public static void main(String[] args) throws Exception {UserInfo userInfo = new UserInfo(1001L,"zhangshan","张三");// 序列化long startTime = System.currentTimeMillis();ByteArrayOutputStream bout = new ByteArrayOutputStream();ObjectOutputStream out = new ObjectOutputStream(bout);out.writeObject(userInfo);out.flush();out.close();System.out.println("原生 JDK 序列化消耗时间：" + (System.currentTimeMillis() - startTime));bout.close();// 原生字节码startTime = System.currentTimeMillis();userInfo.codeC();System.out.println("UserInfo#codeC 消耗时间：" + (System.currentTimeMillis() - startTime));}
}

运行结果：

原生 JDK 序列化消耗时间：9
UserInfo#codeC 消耗时间：1

这差距依然很巨大啊！

所以，Java 原生序列化这么弱，也不能不让我们嫌弃他啊！！！

总结

下面对 Java 序列化做一个总结。

  1. 序列化的目的是为了将 Java 对象的状态持久化存储起来或者在网络上传输。
  2. 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
  3. 如果要序列化的类中包含有引用类型的成员变量，那么该成员变量也需要支持序列化。
  4. 反序列化时必须要有序列化对象的 Class 文件（这里埋坑了）。
  5. 对于 Serializable 接口而言，它只是起到一个标识作用。实现了该接口就意味着该类支持序列化。
    1. 如果我们不想要某个变量被序列化，使用 transient 修饰。
  6. 对于 Externalizable 接口
    1. Externalizable 接口是 Serializable 的子类，它提供了 writeExternal() 和 readExternal() 方法类实现自定义的序列化和反序列化。
    2. writeExternal() 和 readExternal() 两个方法对属性的加工顺序要一致。
  7. 建议所有实现了 Serializable 接口的类都显示申明 serialVersionUID 版本号。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/161433.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Web Woeker和Shared Worker的使用以及案例

Web Woeker和Shared Worker的使用以及案例

文章目录 1、前言2、介绍 Web Worker3、使用须知及兼容性3.1、使用须知3.2、兼容性 4、使用 Web Worker4.1、创建 Web Worker4.2、与主线程通信4.3、终止 Web Worker4.4、监听错误信息 5、使用 Shared Worker4.5、调试 Shared Worker 6、使用中的一些坑6.1、Web Woeker 中引入了…
阅读更多...
【Leetcode】【每日一题】【中等】187. 重复的DNA序列 官方题解待更新

【Leetcode】【每日一题】【中等】187. 重复的DNA序列 官方题解待更新

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/repeated-dna-sequences/descrip…
阅读更多...
带斜杠的能读出来，不带斜杠的读不出来，为什么？

带斜杠的能读出来，不带斜杠的读不出来，为什么？

能读出来。 读不出来，为什么呢？
阅读更多...
高效处理文件：批量顺序编号重命名方法

高效处理文件：批量顺序编号重命名方法

每个人都面临着文件管理的挑战，特别是那些需要处理大量文件的人。如何高效地管理这些文件一直是一个难题。为了解决这个问题，我向大家推荐一款强大的文件管理工具——固乔文件管家。这个工具可以帮助你快速有效地给文件进行批量重命名和编号，…
阅读更多...
《基于先验未知盲反卷积技术的包络谱重复瞬态的循环平稳性提取》阅读笔记及代码整理

《基于先验未知盲反卷积技术的包络谱重复瞬态的循环平稳性提取》阅读笔记及代码整理

论文阅读笔记及代码整理 《Extracting cyclo-stationarity of repetitive transients from envelope spectrum based on prior-unknown blind deconvolution technique》 代码有优化整理过，需要请下载：https://mbd.pub/o/bread/ZZaTl5ht 贡献&#xff1…
阅读更多...
Ubuntu连不上WiFi 或者虽然能连上校园网，但是浏览器打不开登录页面

Ubuntu连不上WiFi 或者虽然能连上校园网，但是浏览器打不开登录页面

写在前面 自己的电脑环境： Ubuntu20.04 一、问题描述 自己的 Ubuntu 遇到连接不上 除校园网之外的其他WiFi, 或者 虽然能连上校园网，但是浏览器打不开登录页面的问题。 二、解决方法 出现这种问题的原因可能是 之前开过VPN, 导致系统的网络设置出现…
阅读更多...
0基础学习VR全景平台篇第117篇：利用插件地拍补地 - PS教程

0基础学习VR全景平台篇第117篇：利用插件地拍补地 - PS教程

上课！全体起立~ 大家好，欢迎观看蛙色官方系列全景摄影课程！ 嗨，大家好，今天我们来介绍【PS利用插件地拍补地】。 之前已经教给大家补地插件的安装方法，今天我们教给大家如何使用这个插件进行补地。 首…
阅读更多...
基于卷尾猴算法的无人机航迹规划-附代码

基于卷尾猴算法的无人机航迹规划-附代码

基于卷尾猴算法的无人机航迹规划 文章目录 基于卷尾猴算法的无人机航迹规划1.卷尾猴搜索算法2.无人机飞行环境建模3.无人机航迹规划建模4.实验结果4.1地图创建4.2 航迹规划 5.参考文献6.Matlab代码 摘要：本文主要介绍利用卷尾猴算法来优化无人机航迹规划。 1.卷尾猴…
阅读更多...
差生文具多之(一)eBPF

差生文具多之(一)eBPF

前言 在问题排查过程中, 通常包含: 整体观测, 数据采集, 数据分析这几个阶段. 对于简单问题的排查, 可以跳过前两个步骤, 无需额外收集数据, 直接通过分析日志中的关键信息就可以定位根因; 而对于复杂问题的排查, 为了对应用的行为有更完整的了解, 可以通过以下形式收集更多的…
阅读更多...
嵌入式中如何将BootLoader与APP合并成一个固件

嵌入式中如何将BootLoader与APP合并成一个固件

1、前言 嵌入式固件一般分为BootLoader和App，BootLoader用于启动校验、App升级、App版本回滚等功能，BootLoader在cpu上电第一阶段中运行，之后跳转至App地址执行应用程序。 因此，在发布固件的时候，会存在BootLoader固件…
阅读更多...
野火霸天虎 STM32F407 学习笔记_1 stm32介绍；调试方法介绍

野火霸天虎 STM32F407 学习笔记_1 stm32介绍；调试方法介绍

STM32入门——基于野火 F407 霸天虎课程学习 前言 博主开始探索嵌入式以来，其实很早就开始玩 stm32 了。但是学了一段时间之后总是感觉还是很没有头绪，不知道在学什么。前前后后分别尝试了江协科技、正点原子、野火霸天虎三次 stm32 的课程学习。江协科…
阅读更多...
【qemu逃逸】HWS2017-FastCP

【qemu逃逸】HWS2017-FastCP

前言 虚拟机用户名：root 虚拟机密码：无密码 本题有符号，所以对于设备定位啥的就不多说了，直接逆向设备吧。 设备逆向 在 realize 函数中设置一个时钟任务，并且可以看到只注册了 mmio，大小为 0x100000。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023