序列化和反序列化详解.

已于 2022-04-02 21:44:34 修改
阅读量773 收藏 2
点赞数
分类专栏： 笔记 文章标签： java
于 2022-04-02 16:44:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwj_07/article/details/123918316
版权

一、序列化和反序列化的理解

 序列化代码演示如下：(内存----> 硬盘文件)

student类：

package com.bjpowernode.java.io;
import java.io.Serializable;

// 序列化对象必须实现Serializable接口 起到标志性作用
public class Student implements Serializable {

    // 属性
    private String name;
    private int age;

    // 构造方法
    public Student() {
    }

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

    // getter and setter方法
    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;
    }

    // toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

代码测试如下：

package com.bjpowernode.java.io;
/*
    1、java.io.NotSerializableException异常

    2、参加序列化和反序列化的对象,必须实现Serializable接口
        此接口起到标志性作用,是给java虚拟机看的,java虚拟机看到这个接口后,会为该类自动生成一个序列化版本号
 */

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws IOException {
        // 创建java对象
        Student student =new Student("junker",5);
        // 创建序列化对象
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream("students"));
        // 序列化对象
        objectOutputStream.writeObject(student);

        // 刷新
        objectOutputStream.flush();
        // 关流
        objectOutputStream.close();
    }
}

结果：

 反序列化代码演示如下：

package com.bjpowernode.java.io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

// 反序列化： 文件----> 内存
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 创反序列化对象
        ObjectInputStream objectInputStream =new ObjectInputStream(new FileInputStream("students"));
        // 开始反序列化 读
        Object o =objectInputStream.readObject();
        System.out.println(o);
        // 关流
        objectInputStream.close();
    }
}

输出结果：

 二、序列化多个对象

代码演示如下：

package com.bjpowernode.java.io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws IOException {
        // 创建一个集合
        ArrayList<User> arrayList =new ArrayList<>();
        // 向集合中添加元素
        arrayList.add(new User("kitty",5));
        arrayList.add(new User("junker",9));

        // 创建序列化对象
        ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("users"));
        // 序列化
        oos.writeObject(arrayList);

        // 刷新
        oos.flush();
        // 关流
        oos.close();
    }

}

结果：

 反序列化多个对象

代码演示如下：

package com.bjpowernode.java.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

// 反序列化  文件》内存
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 创建反序列化对象
        ObjectInputStream ois =new ObjectInputStream(new FileInputStream("users"));
        // 反序列化
        // Object o =ois.readObject();    // 读到的是集合 因为存的时候就是集合
        // System.out.println(o instanceof List);  // true
         List<User> list =(List<User>)ois.readObject();
         for (User data :list){
             System.out.println(data);
         }
    }
}

输出结果： 

 三、transient关键字

package com.bjpowernode.java.io;
import java.io.Serializable;

public class User implements Serializable {

    // 属性
    transient String name;  // transient 不参于序列化 结果 null
    int age;

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

反序列化后的输出结果：

 四、关于序列化版本号

 假设这个User类是我们很久以前写的业务：

package com.bjpowernode.java.io;
import java.io.Serializable;

public class User implements Serializable {
/*
java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号
    // 这里没有手动写出来,java虚拟机会默认提供这个序列化版本号
*/

    // 属性
    String name;
    int age;

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

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 我们通过序列化把它存入到了文件当中

package com.bjpowernode.java.io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

// 序列化  内存----> 文件
public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws IOException {
        // 创建一个集合
        ArrayList<User> arrayList =new ArrayList<>();
        // 向集合中添加元素
        arrayList.add(new User("kitty",5));
        arrayList.add(new User("junker",9));

        // 创建序列化对象
        ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("users"));
        // 序列化
        oos.writeObject(arrayList);

        // 刷新
        oos.flush();
        // 关流
        oos.close();
    }
}

现在我们假定对User这个类当中做了优化/改进 那么我们通过反序列化这个users文件会是什么情况？

报错： java.io.InvalidClassException： stream classdesc serialVersionUID = 7674971421060302263, local class serialVersionUID = -7731114658773239639 

通过报错可以看出第一个序列化版本号和我们修改完User类再次自动生成的序列化版本号不同了

解决方案： 我们可以手动把序列化版本号定义成第一个JVM机看到Serialzable后自动生成的序列化版本号 然后不管我们以后怎么优化修改User类 序列化版本号都是这一个 就可以进行反序列化了

package com.bjpowernode.java.io;
import java.io.Serializable;

public class User implements Serializable {
    
    // 属性
    String name;
    int age;
    private String addr;    // 假定现在优化了User这个类
    

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

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

反序列化该文件：

package com.bjpowernode.java.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

// 反序列化  文件----> 内存
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 创建反序列化对象
        ObjectInputStream ois =new ObjectInputStream(new FileInputStream("users"));
        // 反序列化
        // Object o =ois.readObject();
        // System.out.println(o instanceof List);  // true
         List<User> list =(List<User>)ois.readObject();
         for (User data :list){
             System.out.println(data);
         }
        }
}

原因：

package com.bjpowernode.java.io;
import java.io.Serializable;

public class User implements Serializable {

 /*
    原因： java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号
    // 这里没有手动写出来,java虚拟机会默认提供这个序列化版本号

     */

    // 手动定义成和JVM自动生成的第一个序列化版本号序列化版本号
    private static final long serialVersionUID = 7674971421060302263L;

    // 属性
    String name;
    int age;

    private String addr;    // 假定现在优化了User这个类

    // 过了很久,User这个类源代码改动了
    // 源代码改动后需要重新编译,编译之后生成了全新的字节码文件
    // 并且class文件再次运行的时候,java虚拟机生成的序列化版本号也会发生相应的改变
    // (相当于第一个User implements Serializable 这个类没修改前是两个属性 name 、age java虚拟机看到Serializable接口之后自动生成
    // 一个序列化版本号      当我们修改这个User implements Serializable这个类之后 不再和第一个类一样,java虚拟机看到Serializable接口
    // 后又会自动生成一个序列化版本号  修改前后的序列化版本号不同 所以当我们再次反序列化此文件的时候就会出现报错异常)

    // 解决方案： 我们可以手动定义一个序列化版本号,让User这个类修改前后的序列化版本号固定一样,那么我们就可以反序列化了


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

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

手动定义序列化版本号后反序列化结果：

package com.bjpowernode.java.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

// 反序列化  文件----> 内存
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 创建反序列化对象
        ObjectInputStream ois =new ObjectInputStream(new FileInputStream("users"));
        // 反序列化
        // Object o =ois.readObject();
        // System.out.println(o instanceof List);  // true
         List<User> list =(List<User>)ois.readObject();
         for (User data :list){
             System.out.println(data);
         }
        }
}

lwj_07
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
序列化和反序列化
nO0b
12-01 199
把对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为对象的过程称为对象的反序列化。 序列化的目的: 1、以某种存储形式使自定义对象持久化； 2、将对象从一个地方传递到另一个地方。 3、使程序更具维护性。 应用: 对象的序列化主要有两种用途： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中； 在网络上传送对象的字节序列。 在很多应用中，需要对某些对象进行序列化，让它...
JAVA序列化和反序列化的底层实现原理解析
08-25
主要介绍了JAVA序列化和反序列化的底层实现原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
序列化与反序列化介绍
热门推荐
shsh1234567890的博客
01-23 1万+
序列化与反序列化介绍
一文带你了解序列化与反序列化基本原理与操作
m0_68987535的博客
07-06 1万+
序列化是指将对象转换为字节序列的过程，以便于存储或传输。在序列化过程中，对象的状态信息将被转换为字节流，可以保存到文件中或通过网络传输给其他计算机。反序列化则是将字节序列恢复为对象的过程。通过反序列化操作，可以从存储的字节流中还原对象的状态。这使得可以在程序重启后，读取保存的字节流并重新构造对象，从而快速恢复对象的状态。在分布式系统中，可以将对象进行序列化，并在不同的计算机之间进行传输。接收方可以通过反序列化操作将字节序列转换为可操作的对象。某些远程通信框架使用序列化和反序列化来实现远程方法调用。
Java序列化Serializable源码
xyjy11的博客
07-06 403
Java序列化Serializable 示例分析和源码跟踪
详解PHP序列化和反序列化原理
10-18
本篇文章给大家分享了下PHP反序列化漏洞系列之PHP序列化和反序列化原理的相关知识，有这方面需要的朋友参考学习下吧。
Java中对象序列化与反序列化详解
09-03
3. **完全自定义序列化**：如果类实现了`Externalizable`接口，那么需要手动编写`writeExternal()`和`readExternal()`方法，完全控制序列化和反序列化的过程。 **三、`Serializable`接口** `Serializable`接口是一...
详解Java 对象序列化和反序列化
08-30
Java提供了内置的支持来进行对象的序列化和反序列化，主要通过实现`java.io.Serializable`接口来实现。 1. **简洁的代码实现** Java对象序列化的简化代码主要体现在使用`ObjectOutputStream`和`ObjectInputStream`...
PHP 序列化和反序列化函数实例详解
12-20
值得注意的是，虽然序列化和反序列化提供了很大的便利，但也有潜在的安全风险。例如，反序列化过程中可能会触发未预期的代码执行，特别是在处理用户输入的数据时。因此，开发者应当谨慎对待反序列化操作，确保数据...
Java 序列化和反序列化实例详解
08-31
Java 序列化和反序列化实例详解 Java 序列化和反序列化是 Java 语言中两个重要的概念，它们在分布式应用中扮演着至关重要的角色。序列化是指将对象转换为字节流的过程，而反序列化则是指将字节流恢复为对象的过程。...
java中序列化与反序列化
weixin_43167662的博客
09-19 1788
一、基本概念 1、序列化和反序列化的定义： (1)Java序列化就是指把Java对象转换为字节序列的过程 Java反序列化就是指把字节序列恢复为Java对象的过程。 (2)序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。 反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。 总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息） 2、j
java序列化与反序列化全讲解
追光者的博客
06-03 1706
java序列化与反序列化全讲解
Java中序列化接口Serializable的serialVersionUID的作用
IT利刃出鞘的博客
12-30 3140
本文介绍Java中序列化接口Serializable的serialVersionUID的作用。
使用StringRedisTemplate手动序列化JSON对象到Redis，并手动反序列化从redis中取出数据
weixin_45460791的博客
07-05 479
【代码】使用StringRedisTemplate手动序列化JSON对象到Redis，并手动反序列化从redis中取出数据。
一文搞懂序列化与反序列化
m0_56183421的博客
12-07 1226
什么是序列化与反序列化？他们是用来干啥的？怎样实现序列化？理解常用的序列化与反序列化这一篇就够了！
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1160
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java对象序列化与反序列化详解
"Java对象的序列化与反序列化技术详解" Java对象的序列化与反序列化是Java编程中的一项重要技术，它允许我们将Java对象转换为字节流，以便于存储或在网络中传输。这章内容主要涵盖以下几个方面： 1. **对象序列化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值