是时候放弃 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.mzph.cn/news/131830.shtml

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

相关文章

linux傻瓜式安装Java环境及中间件

linux傻瓜式安装Java环境及中间件

linux配置Java环境及中间件 1.傻瓜式安装Java1.下载2.追加3.刷新测试 2.傻瓜式安装docker1.docker卸载2.docker安装 3.Docker傻瓜式安装Redis1.傻瓜式安装安装并配置 4.Docker傻瓜式安装RabbitMQ5.Docker傻瓜式安装MySql1.拉取2.配置 6.傻瓜式安装Nacos1.官网下载nacos2.SQL文件…
阅读更多...
vue2.0 打包，nginx部署

vue2.0 打包，nginx部署

1、修改这里为空 否则报错：vue is undefined 2、修改为hash，重点：打包dist文件运行，必须这样 3、安装ngnix，重点：使用node的包：httpserve，失败 4、重点：配置代理转发 前端…
阅读更多...
MySQL：事务

MySQL：事务

目录 概念事务特性开始事务事务的状态事务并发问题事务隔离级别 概念 MySQL事务是一组在数据库中执行的操作，它们必须要么全部成功执行，要么全部不执行。MySQL事务被设计为确保数据库中的数据的完整性和一致性，即使在并发访问的情况下也是如…
阅读更多...
MySQL进阶之性能优化与调优技巧

MySQL进阶之性能优化与调优技巧

数据库开发-MySQL 1. 多表查询1.1 概述1.1.2 介绍1.1.3 分类 1.2 内连接1.3 外连接1.4 子查询1.4.1 介绍1.4.2 标量子查询1.4.3 列子查询1.4.4 行子查询1.4.5 表子查询 2. 事务2.1 介绍2.2 操作2.3 四大特性 3. 索引3.1 介绍3.2 结构3.3 语法 1. 多表查询 1.1 概述 1.1.2 介绍…
阅读更多...
上线Spring boot-若依项目

上线Spring boot-若依项目

基础环境 所有环境皆关闭防火墙与selinux 服务器功能主机IP主机名服务名称配置前端服务器192.168.231.177nginxnginx1C2G后端服务器代码打包192.168.231.178javajava、maven、nodejs4C8G数据库/缓存192.168.231.179dbmysql、redis2C4G Nginx #配置Nginxyum源 [rootnginx ~]…
阅读更多...
基于葡萄串的采摘点定位方法

基于葡萄串的采摘点定位方法

文章目录 概要所需设备方法基于RGB图像的YOLOV8目标检测基于深度图的区域种子生长利用峰值定位法来确定竖向位置核心代码演示效果概要 这里将介绍如何用图像识别方法来定位葡萄串采摘点，用于机器人自动采摘操作。 所需设备 深度相机，这里我用的是realsense-L515 方法 主…
阅读更多...
Spring Boot Actuator 漏洞利用

Spring Boot Actuator 漏洞利用

文章目录 前言敏感信息泄露env 泄露配置信息trace 泄露用户请求信息mappings 泄露路由信息heapdump泄露堆栈信息 前言 spring对应两个版本，分别是Spring Boot 2.x和Spring Boot 1.x，因此后面漏洞利用的payload也会有所不同 敏感信息泄露 env 泄露配置信…
阅读更多...
野火霸天虎 STM32F407 学习笔记_2 寄存器介绍

野火霸天虎 STM32F407 学习笔记_2 寄存器介绍

寄存器 虽然正式编程没有必要用寄存器编程，通常都是库函数或者 hal 库。但是还是有必要学一下原理的。 寄存器映射 芯片视图如下。 丝印：芯片上印的信息。型号，内核，生产批次等。 引脚：左上角是有小圆点的&#x…
阅读更多...
Android性能优化--Perfetto用SQL性能分析

Android性能优化--Perfetto用SQL性能分析

Android性能优化–Perfetto用SQL性能分析 文章目录 Android性能优化--Perfetto用SQL性能分析介绍Perfetto SQL 基础使用 Perfetto SQL 进行性能分析总结 本文首发地址 https://blog.csdn.net/CSqingchen/article/details/134167741 最新更新地址 https://gitee.com/chenjim/che…
阅读更多...
Git（七）.git 文件夹瘦身，GitLab 永久删除文件

Git（七）.git 文件夹瘦身，GitLab 永久删除文件

目录 一、问题背景二、问题复现2.1 新建项目2.2 上传大文件2.3 上传结果 三、解决方案3.1 GitLab备份与还原1）备份2）还原 3.2 删除方式一：git filter-repo 命令【推荐】1）安装2）删除本地仓库文件3）重新关联…
阅读更多...
将 UniLinks 与 Flutter 集成（安卓 AppLinks + iOS UniversalLinks）

将 UniLinks 与 Flutter 集成（安卓 AppLinks + iOS UniversalLinks）

让我们使用 Flutter Mobile 和 Flutter Web 集成 UniLinks。 一步一步的指导！ 我是 Pedro Dionsio，是葡萄牙 InspireIT 公司的 Flutter 开发人员，我写这个 UniLinks 教程的座右铭是： Firebase DynamicLinks 已被弃用&#xff0…
阅读更多...
机器学习笔记 - 感知器的数学表达

机器学习笔记 - 感知器的数学表达

一、假设前提 感知机（或称感知器，Perceptron）是Frank Rosenblatt在1957年就职于Cornell航空实验室（Cornell Aeronautical Laboratory）时所发明的一种人工神经网络。 它可以被视为一种最简单形式的前馈神经网络，是一种二元线性分类模型，其输入为实例的特征向量，输出为实…
阅读更多...
同为科技（TOWE）自动断电倒计时定时桌面PDU插排

同为科技（TOWE）自动断电倒计时定时桌面PDU插排

在每个家庭中，插排插座都是必不可少的电源设备。随着各种电器的普及应用和生活节奏的加快，人们对插排也有着多样化的需求，比如在插排中加入定时开关、自动断电、断电记忆、倒计时等等功能，让原本不支持智能家居的用电器秒变智能。…
阅读更多...
Mysql高级——Mysql8一主一从，多主多从搭建

Mysql高级——Mysql8一主一从，多主多从搭建

修改 /etc/hosts文件 ip地址 master1 ip地址 master2 ip地址 slave1 ip地址 slave2一主一从 create database master1db;create table master1db.master1tab(name char(50));insert into master1db.master1tab VALUES(1111);insert into master1db.master1tab VALUES(2222);m…
阅读更多...
Linux命令--mkdir创建目录的方法

Linux命令--mkdir创建目录的方法

原文网址&#xff1a;Linux命令--mkdir创建目录的方法_IT利刃出鞘的博客-CSDN博客 简介 本文介绍Linux创建目录命令--mkdir的用法。 格式 mkdir [选项] 目录… -m, –mode模式&#xff0c;设定权限<模式> (类似 chmod)&#xff0c;而不是 rwxrwxrwx 减 umask-p, --p…
阅读更多...
按键开发环境搭建

按键开发环境搭建

雷电模拟器 创建虚拟机 2.设置root权限 打开按键精灵连接虚拟机 开启悬浮 mumu模拟器操作 查找端口方法 adb connect 127.0.0.1:16416 设置-应用-所有应用-按键精灵-开启悬浮 步骤二&#xff1a;开启root 处理未root&#xff1a;中途如果有如下未root的情况&#x…
阅读更多...
基于SSM的网吧计费管理系统（有报告）。Javaee项目，ssm项目。

基于SSM的网吧计费管理系统（有报告）。Javaee项目，ssm项目。

演示视频&#xff1a; 基于SSM的网吧计费管理系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;ssm项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通…
阅读更多...
Monarch Mixer：一种性能比Transformer更强的网络架构

Monarch Mixer：一种性能比Transformer更强的网络架构

六年前&#xff0c;谷歌团队在arXiv上发表了革命性的论文《Attention is all you need》。作为一种优势的机器学习网络架构&#xff0c;Transformer技术迅速席卷全球。Transformer一直是现代基础模型背后的主力架构&#xff0c;并且在不同的应用程序中取得了令人印象深刻的成功…
阅读更多...
OCS2工具箱

OCS2工具箱

实时系统优化控制工具箱 参考视频&#xff1a;ETH 最优控制/MPC 实时求解器 OCS2 使用入门 参考文档&#xff1a;OCS2 求解器入门 选择OCS2 OCS2 是一个 MPC 实时求解器 (SLQ/iLQR)&#xff0c;依赖 Pinocchio 构建机器人动力学模型&#xff0c;采用 RViz 或者 RaiSim 验证 (…
阅读更多...
[LeetCode] 2.两数相加

[LeetCode] 2.两数相加

一、题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023