百度360必应搜狗淘宝本站头条
docker systemdzabbix微信报警脚本loadjsqt5.5pagination.js
当前位置：网站首页 > 技术教程 > 正文

吊打面试官:什么是Java序列化与反序列化?

suiw9 2025-02-08 12:49 30 浏览 0 评论

#头条创作挑战赛#

序列化和反序列化的概念

大家好，我是呼噜噜，当我们在Java中创建对象的时候，对象会一直存在，直到程序终止时。但有时候可能存在一种"持久化"场景：我们需要让对象能够在程序不运行的情况下，仍能存在并保存其信息。当程序再次运行时 还可以通过该对象的保存下来的信息 来重建该对象。序列化和反序列化 就应运而生了，序列化机制可以使对象可以脱离程序的运行而独立存在。

  • 序列化： 将对象转换成二进制字节流的过程
  • 反序列化：从二进制字节流中恢复对象的过程

应用场景？

  1. 对象在进行网络传输的时候，需要先被序列化，接收到序列化的对象之后需要再进行反序列化；比如远程方法调用 RPC
  2. 将对象存储到文件中的时候需要进行序列化，将对象从文件中读取出来需要进行反序列化。
  3. 将对象存储到内存中，需要进行序列化，将对象从内存中读取出来需要进行反序列化。
  4. 将对象存储到数据库（如 Redis）时，需要用到序列化，将对象从缓存数据库中读取出来需要反序列化。

序列化实现的方式

如果使用Jdk自带的序列化方式实现对象序列化的话，那么这个类应该实现Serializable接口或者Externalizable接口

继承Serializable接口，普通序列化

首先我们定义一个对象类User

public class User implements Serializable {
    //序列化ID
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

然后我们编写一下测试类：

public class serTest {
    public static void main(String[] args) throws Exception, IOException {
        SerializeUser();
        DeSerializeUser();
    }

    /**
     * 序列化方法
     * @throws IOException
     */
    private static void SerializeUser() throws  IOException {
        User user = new User(11, "小张");

        //序列化对象到指定的文件中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example"));
        oos.writeObject(user);
        oos.close();
        System.out.println("序列化对象成功");
    }

    /**
     * 反序列化方法
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static void DeSerializeUser() throws  IOException, ClassNotFoundException {
        //读取指定的文件
        File file = new File("C:\\Users\\jun\\Desktop\\example");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        User newUser = (User)ois.readObject();
        System.out.println("反序列化对象成功:"+ newUser.getName()+ ","+newUser.getAge());
    }
}

结果：

序列化对象成功

反序列化对象成功:小张,11

一个对象想要被序列化，那么它的类就要继承Serializable接口或者它的子接口

继承Serializable接口类的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。如果不想序列化的字段可以使用transient关键字修饰

private int age;
private String name;
private transient password;//属性：密码，不想被序列化

我们需要注意的是：使用transient关键字阻止序列化虽然简单方便，但被它修饰的属性被完全隔离在序列化机制之外，这必然会导致了在反序列化时无法获取该属性的值。 其实我们完全可以在通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法来控制如何序列化各属性，某些属性是否被序列化

如果User有一个属性是引用类型的呢？比如User其中有一个属性是类Person:

private Person person;

那如果要想User可以序列化，那Person类也必须得继承Serializable接口，不然程序会报错

另外大家应该注意到serialVersionUID了吧，在日常开发的过程中，经常遇到，暂且放放，我们后文再详细讲解

继承Externalizable接口，强制自定义序列化

对于Externalizable接口，我们需要知道以下几点：

  1. Externalizable继承自Serializable接口
  2. 需要我们重写writeExternal()与readExternal()方法，这是强制性的
  3. 实现Externalizable接口的类必须要提供一个public的无参的构造器，因为反序列化的时候需要反射创建对象
  4. Externalizable接口实现序列化，性能稍微比继承自Serializable接口好一点

首先我们定义一个对象类ExUser

public class ExUser implements Externalizable {
    private int age;
    private String name;

    //注意，必须加上pulic 无参构造器
    public ExUser() {
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = (String)in.readObject();
        this.age = in.readInt();
    }
}

我们接着编写测试类：

public class serTest2 {
    public static void main(String[] args) throws Exception, IOException {
        SerializeUser();
        DeSerializeUser();
    }

    /**
     * 序列化方法
     * @throws IOException
     */
    private static void SerializeUser() throws  IOException {
        ExUser user = new ExUser();
        user.setAge(10);
        user.setName("小王");

        //序列化对象到指定的文件中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example"));
        oos.writeObject(user);
        oos.close();
        System.out.println("序列化对象成功");
    }

    /**
     * 反序列化方法
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static void DeSerializeUser() throws  IOException, ClassNotFoundException {
        File file = new File("C:\\Users\\jun\\Desktop\\example");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        ExUser newUser = (ExUser)ois.readObject();
        System.out.println("反序列化对象成功:"+ newUser.getName()+ ","+newUser.getAge());
    }
}

结果：

序列化对象成功

反序列化对象成功:小王,10

因为序列化和反序列化方法需要自己实现，因此可以指定序列化哪些属性，transient关键字在这里是无效的。

对Externalizable对象反序列化时，会先调用类的无参构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常，因此Externalizable对象必须有默认构造函数，而且必需是public的。

serialVersionUID的作用

如果反序列化使用的serialVersionUID与序列化时使用的serialVersionUID不一致，会报InvalidCalssException异常。这样就保证了项目迭代升级前后的兼容性 serialVersionUID是序列化前后的唯一标识符，只要版本号serialVersionUID相同，即使更改了序列化属性，对象也可以正确被反序列化回来。 默认如果没有人为显式定义过serialVersionUID，那编译器会为它自动声明一个！

serialVersionUID有两种显式的生成方式：

  1. 默认的1L，比如：private static final long serialVersionUID = 1L;
  2. 根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：

private static final long serialVersionUID = xxxxL;

静态变量不会被序列化

凡是被static修饰的字段是不会被序列化的，我们来看一个例子：

//实体类
public class Student implements Serializable {
    private String name;
    public static Integer age;//静态变量



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static Integer getAge() {
        return age;
    }

    public static void setAge(Integer age) {
        Student.age = age;
    }
}

//测试类
public class shallowCopyTest {

    public static void main(String[] args) throws Exception {
        Student student1 = new Student();
        student1.age = 11;

        //序列化，将数据写入指定的文件中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\student1"));
        oos.writeObject(student1);
        oos.close();

        Student student2 = new Student();
        student2.age = 21;

        //序列化，将数据写入指定的文件中
        ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream("D:\\student2"));
        oos2.writeObject(student1);
        oos2.close();

        //读取指定的文件
        File file = new File("D:\\student1");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Student student1_new = (Student)ois.readObject();
        System.out.println("反序列化对象,student1.age="+ student1_new.getAge());

        //读取指定的文件
        File file2 = new File("D:\\student1");
        ObjectInputStream ois2 = new ObjectInputStream(new FileInputStream(file2));
        Student student2_new = (Student)ois2.readObject();
        System.out.println("反序列化对象,student2.age="+ student2_new.getAge());


    }



}

结果：

反序列化对象,student1.age=21

反序列化对象,student2.age=21

为啥结果都是21？ 我们知道对象的序列化是操作的堆内存中的数据，而静态的变量又称作类变量，其数据存放在方法区里，类一加载，就初始化了。 又因为静态变量age没有被序列化，根本就没写入文件流中，所以我们打印的值其实一直都是当前Student类的静态变量age的值，而静态变量又是所有的对象共享的一个变量，所以就都是21

使用序列化实现深拷贝

我们再来看一个例子：

//实体类 继承Cloneable
public class Person implements Serializable{
    public String name;//姓名
    public int height;//身高
    public StringBuilder something;

...//省略 getter setter


    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
    
        oos.writeObject(this);
    
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
    
        return ois.readObject();
    }

}

//测试类，这边类名笔者就不换了，在之前的基础上改改
public class shallowCopyTest {

    public static void main(String[] args) throws Exception {
        Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
        Person p2 = (Person)p1.deepClone();

        System.out.println("对象是否相等："+ (p1 == p2));
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());


        // change
        p1.setName("小王");
        p1.setHeight(200);
        p1.getSomething().append(",适合出去玩");
        System.out.println("...after p1 change....");

        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());

    }
}

结果：

对象是否相等：false

p1 属性值=小张,180,今天天气很好

p2 属性值=小张,180,今天天气很好

...after p1 change....

p1 属性值=小王,200,今天天气很好,适合出去玩

p2 属性值=小张,180,今天天气很好

详情见：
https://mp.weixin.qq.com/s/M4--Btn24NIggq8UBdWvAw

常见序列化协议对比

除了JDK 自带的序列化方式，还有一些其他常见的序列化协议：

  1. 基于二进制： hessian、kyro、protostuff
  2. 文本类序列化方式： JSON 和 XML

采用哪种序列化方式，我们一般需要考虑序列化之后的数据大小，序列化的耗时，是否支持跨平台、语言，或者公司团队的技术积累。这边就不展开讲了，大家感兴趣自行去了解

小结

  1. JDK自带序列化方法一般有2种：继承Serializable接口和继承Externalizable接口
  2. static修饰的类变量、transient修饰的实例变量都不会被序列化。
  3. 序列化对象的引用类型成员变量，也必须是可序列化的
  4. serialVersionUID 版本号是序列化和反序列化前后唯一标识，建议显式定义
  5. 序列化和反序列化的过程其实是有漏洞的，因为从序列化到反序列化是有中间过程的，如果被别人拿到了中间字节流，然后加以伪造或者篡改，反序列化出来的对象会有一定风险。可以重写readObject()方法，加以限制
  6. 除了JDK自带序列化方法，还有hessian、kyro、protostuff、 JSON 和 XML等



本篇文章到这里就结束啦，如果我的文章对你有所帮助，还请帮忙一键三连：点赞、关注、收藏，你的支持会激励我输出更高质量的文章，感谢！

计算机内功、JAVA源码、职业成长、项目实战、面试相关等更多高质量文章，首发于公众号「小牛呼噜噜」，我们下期再见。

相关推荐

5款Syslog集中系统日志常用工具对比推荐

一、为何要集中管理Syslog？Syslog由Linux/Unix系统及其他网络设备生成，广泛分布于整个网络。因其包含关键信息，可用于识别网络中的恶意活动，所以必须对其进行持续监控。将Sys...

跨平台、多数据库支持的开源数据库管理工具——DBeaver

简介今天给大家推荐一个开源的数据库管理工具——DBeaver。它支持多种数据库系统，包括Mysql、Oracle、PostgreSQL、SLQLite、SQLServer等。DBeaver的界面友好...

强烈推荐!数据库管理工具:Navicat Premium 16.3.2 (64位)

NavicatPremium，一款集数据迁移、数据库管理、SQL/查询编辑、智能设计、高效协作于一体的全能数据库开发工具。无论你是MySQL、MariaDB、MongoDB、SQLServer、O...

3 年 Java 程序员还玩不转 MongoDB，网友:失望

一、什么场景使用MongoDB？...

拯救MongoDB管理员的GUI工具大赏:从菜鸟到极客的生存指南

作为一名在NoSQL丛林中披荆斩棘的数据猎人，没有比GUI工具更称手的瑞士军刀了。本文将带你围观五款主流MongoDB管理神器的特性与暗坑，附赠精准到扎心的吐槽指南一、MongoDBCompass：...

mongodb/redis/neo4j 如何自己打造一个 web 数据库可视化客户端?

前言最近在做neo4j相关的同步处理，因为产线的可视化工具短暂不可用，发现写起来各种脚本非常麻烦。...

solidworks使用心得，纯干货!建议大家收藏

SolidWorks常见问题...

统一规约-关乎数字化的真正实现（规范统一性）

尽管数字化转型的浪潮如此深入人心，但是，对于OPCUA和TSN的了解却又甚少，这难免让人质疑其可实现性，因为，如果缺乏统一的语义互操作规范，以及更为具有广泛适用的网络与通信，则数字化实际上几乎难以具...

Elasticsearch节点角色配置详解(Node)

本篇文章将介绍如下内容：节点角色简介...

产前母婴用品分享 篇一:我的母婴购物清单及单品推荐

作者：DaisyH8746在张大妈上已经混迹很久了，有事没事看看“什么值得买”已渐渐成了一种生活习惯，然而却从来没有想过自己要写篇文章发布上来，直到由于我产前功课做得“太过认真”（认真到都有点过了，...

比任何人都光彩照人的假期!水润、紧致的肌肤护理程序

图片来源：谜尚愉快的假期临近了。身心振奋的休假季节。但是不能因为这种心情而失去珍贵的东西，那就是皮肤健康。炙热的阳光和强烈的紫外线是使我们皮肤老化的主犯。因此，如果怀着快乐的心情对皮肤置之不理，就会使...

Arm发布Armv9边缘AI计算平台，支持运行超10亿参数端侧AI模型

中关村在线2月27日消息，Arm正式发布Armv9边缘人工智能（AI）计算平台。据悉，该平台以全新的ArmCortex-A320CPU和领先的边缘AI加速器ArmEthos-U85NPU为核心...

柔性——面向大规模定制生产的数字化实现的基本特征

大规模定制生产模式的核心是柔性，尤其是体现在其对定制的要求方面。既然是定制，并且是大规模的定制，对于制造系统的柔性以及借助于数字化手段实现的柔性，就提出了更高的要求。面向大规模定制生产的数字化业务管控...

创建PLC内部标准——企业前进的道路

作者：FrankBurger...

标准化编程之 ----------- 西门子LPMLV30测试总结

PackML乃是由OMAC开发且被ISA所采用的自动化标准TR88.00.02，能够更为便捷地传输与检索一致的机器数据。PackML的主要宗旨在于于整个工厂车间倡导通用的“外观和感觉”，...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表
Copyright Your WebSite.Some Rights Reserved.