java中序列化和反序列化详细分析

qq_45764329

已于 2022-03-10 11:00:18 修改

阅读量348

点赞数

分类专栏： Java基础文章标签： java 开发语言网络协议

于 2022-03-09 18:45:49 首次发布

本文链接：https://blog.csdn.net/qq_45764329/article/details/123376370

版权

Java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.基本概念

1.1 什么是序列化和反序列化

序列化：指将java对象转换为字节序列(本质上是一个byte[]数组)的过程。需要使用ObjectOutputStream类
反序列化：将字节序列转换为java对象的过程。需要使用ObjectInputStream类

本质上来说:序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。

1.2 为什么需要使用序列化和反序列化

当两个java 进程进行通信时，发送方需要把这个Java 对象转换为字节序列，然后在网络上传输，接收方则需要从字节序列中恢复出java对象。
java 序列化的好处
实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（如：存储在文件里），实现永久1保存对象
利用序列化实现远程通信，即：能够在网络上传输对象

2.如何实现java 序列化和反序列化

只要对象实现了Serializable、Externalizable 接口（该接口仅仅是一个标记接口，不包含任何方法），则该对象就实现了序列化

2.1 具体是如何实现的？

细节补充：
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中

API接口

序列化和反序列化需要使用两个类的api接口
①java.io.ObjectInputStream：对象输入流
②java.io.ObjectOutputStream：对象输出流

序列化：首先要创建某些OutputStream 对象，然后将其封装在一个ObjectOutputStream 对象类，这时调用writeObject() 方法，即可将对象序列化，并将其发送给OutputStream(对象序列化是基于字节的，因此使用的InputStream和 OutputStream继承的类)
反序列化：即反向进行序列化的过程，需要将一个InputStream 封装在ObjectInputStream 对象内，然后调用readObject() 方法，获得一个对象引用（它是指向一个向上转型的Object），然后进行类型强制转换得到该对象。

假定一个User 类，它的对象需要序列化，可以有如下三种方法：
(1) 若User 类仅仅实现了Serializeable 接口，则可以按照以下方式进行序列化和反序列化
ObjectOutputStream 采用默认的序列化方式，对User 对象的非transient 的实例变量进行序列化
ObjectInputStream 采用默认的反序列化方式，对User对象的非transient 的实例变量进行反序列化
(2) 若User 类仅仅实现了Serializable 接口，并且还定义了readObject(ObjectInputStream in)和writeObject ( ObjectOutputStream out),则采用以下方式进行序列化和反序列化
ObjectOutputStream调用User 对象的writeObject ( ObjectOutputStream out)的方法进行序列化
ObjectInputStream 会调用User对象的readObject(ObjectInputStream in)进行反序列化
(3) 若User类实现了Externalnalizable接口，且User类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。
ObjectOutputStream调用User对象的writeExternal(ObjectOutput out))的方法进行序列化。
ObjectInputStream会调用User对象的readExternal(ObjectInput in)的方法进行反序列化

java.io.ObjectOutputStream :对象输出流，它的writeObject(Object obj)方法可以对指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream: 对象输入流，它的readObject() 方法可以将从输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回

Serializable 接口
- 一般出现这个错误java.io.NotSerializableException，说明创建的实体类对象没有继承序列化
- 参与序列化和反序列化的实体类对象，必须实现Serializable
- 参与序列化的ArrayList 集合以及集合中的元素User都需要实现java.io.Serializable.

2.3 什么场景下需要序列化

当你想把内存中的对象状态保存到一个文件中或者数据库中时候
当你想用套接字在网络上传送对象的时候
当你想通过RMI传输对象的时候

3.注意事项

当一个父类实现序列化，子类就会自动实现序列化，不需要显示实现Serializable 接口
当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化
并非所有的对象都可以进行序列化，比如：

安全方面的原因，比如一个对象拥有private,public等成员变量，对于一个要传输的对象，比如写到文件，或者进行RMI传输等等，在序列化进行传输的过程当中，这个对象的private等域是不受保护的。
资源分配方面的原因，比如socket,thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现的。

声明为static 和transient 类型的成员变量不能被序列化。因为static 代表类的状态，transient代表对象的临时数据。
序列化运行时会使用一个称为 serialVersionUID 的版本号，并与每个可序列化的类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 “serialVersionUID” 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID。
序列化运行时会使用一个称为 serialVersionUID 的版本号，并与每个可序列化的类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 “serialVersionUID” 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID。

如果序列化的类未显式的声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java™ 对象序列化规范”中所述。不过，强烈建议所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 – serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。

java 有很多基础类已经实现了serializable 接口，比如String,Vector等。但是也有没有实现的
如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存！这就是能用序列化解决深浅拷贝的重要原因。

4.代码实战

4.1 对象代码实战

先创建一个实体类

public class Student implements Serializable {

    private int no;
    private String name;

    public Student() {
    }

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

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


}

4.1.1 序列化

通过序列其对象

public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception{
        // 创建java对象
        Student s = new Student(1111, "zhangsan");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));

        // 序列化对象
        oos.writeObject(s);

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

查看其文件目录的时候
会生成一个students的文件
文件内部大致如下
在这里插入图片描述

4.1.2 反序列化

具体代码为：

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/*
反序列化
 */
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
        // 开始反序列化，读
        Object obj = ois.readObject();
        // 反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
        System.out.println(obj);
        ois.close();
    }
}

通过反序列化的输出，在终端中输出页面显示为
在这里插入图片描述

4.2 集合-代码实战

一般不可以直接传输多个对象进行序列化或者反序列化
应该将多个对象放到集合中去

transient 关键字表示游离的，不参与序列化
将其添加到属性，不参与序列化，最后生成的反序列化的值是null；
java的transient 关键字为我们提供了便利，你只需要实现Serilizable 接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

先创建一个实体类:

import java.io.Serializable;

public class User implements Serializable {
    private int no;
    // transient关键字表示游离的，不参与序列化。
    private transient String name; // name不参与序列化操作！

    public User() {
    }

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

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

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

4.2.1 序列化

代码具体为：

public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws Exception{
        List<User> userList = new ArrayList<>();
        userList.add(new User(1,"zhangsan"));
        userList.add(new User(2, "lisi"));
        userList.add(new User(3, "wangwu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));

        // 序列化一个集合，这个集合对象中放了很多其他对象。
        oos.writeObject(userList);

        oos.flush();
        oos.close();
    }
}

4.2.2 反序列化

/*
反序列化集合
 */
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));
        //Object obj = ois.readObject();
        //System.out.println(obj instanceof List);
        List<User> userList = (List<User>)ois.readObject();
        for(User user : userList){
            System.out.println(user);
        }
        ois.close();
    }
}

qq_45764329

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java中序列化和反序列化详细分析

1.基本概念1.1 什么是序列化和反序列化序列化：指将java对象转换为字节序列(本质上是一个byte[]数组)的过程。需要使用ObjectOutputStream类反序列化：将字节序列转换为java对象的过程。需要使用ObjectInputStream类本质上来说:序列化就是把实体对象状态按照一定的格式写入到有序字节流，反序列化就是从有序字节流重建对象，恢复对象状态。1.2 为什么需要使用序列化和反序列化当两个java 进程进行通信时，发送方需要把这个Java 对象转换为字节序列，然后在
复制链接

扫一扫

专栏目录