Java中的序列化和反序列化

最新推荐文章于 2022-11-04 17:21:09 发布
最新推荐文章于 2022-11-04 17:21:09 发布
阅读量115 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42119753/article/details/100868968
版权

目录

 

序列化的含义和意义

对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，通过网络将这种二进制流传输到另一个网络节点。其他程序一旦获得了这种二进制流，都可以将这种二进制流恢复成原来的Java对象。 

对象序列化机制（object serialization）是Java语言内建的一种对象持久化方式，通过对象序列化，可以把对象保存为字节数组，这些字节数组可以保存在磁盘上，或通过网络传输。在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。对象序列化可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。

在Java中，对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中。通常建议：程序创建的每个JavaBean类都实现Serializable。

 

相关接口和类

Java为了方便开发人员将Java对象进行序列化及反序列化提供了一套方便的API来支持。其中包括以下接口和类：

java.io.Serializable

java.io.Externalizable

ObjectOutput

ObjectInput

ObjectOutputStream

ObjectInputStream

Serializable接口

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

下面是一个实现了java.io.Serializable接口的类

import java.io.Serializable;
public class User1 implements Serializable {

    private String name;
    private int age;

    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;
    }

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

通过下面的代码进行序列化及反序列化


import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;

import java.io.*;

public class SerializableDemo1 {

    public static void main(String[] args) {
        //Initializes The Object
        User1 user = new User1();
        user.setName("hollis");
        user.setAge(23);
        System.out.println(user);

        //Write Obj to File
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(oos);
        }

        //Read Obj from File
        File file = new File("tempFile");
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(file));
            User1 newUser = (User1) ois.readObject();
            System.out.println(newUser);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(ois);try{FileUtils.forceDelete(file);}catch(IOException e){
                e.printStackTrace();}}}}//OutPut://User{name='hollis', age=23}//User{name='hollis', age=23}

使用对象流实现序列化

反序列化机制无须通过构造器来初始化Java对象。

如果使用序列化机制向文件中写入多个Java对象，使用反序列化机制恢复对象时必须按实际写入的顺序读取。

当一个可序列化类有多个父类时（包括直接父类和间接父类），这些父类要么有无参数的构造器，要么也是可序列化的——否则反序列化时将抛出InvalidClassException异常。如果父类是不可序列化的，只是带有无参数的构造器，则该父类中定义的Field值不会序列化到二进制流中。

对象引用的序列化

当程序序列化一个Teacher对象时，如果该Teacher对象持有一个Person对象的引用，为了在反序列化时可以正常恢复该Teacher对象，程序会顺带将该Person对象也进行序列化，所以Person类也必须是可序列化的，否则Teacher类将不可序列化。

当使用Java序列化机制序列化可变对象时一定要注意，只有第一次调用writeObject()方法来输出对象时才会将对象转换成字节序列，并写入到ObjectOutputStream；在后面程序中即使该对象的Field发生了改变，再次调用writeObject()方法输出该对象时，改变后的Field也不会被输出。

Externalizable接口

除了Serializable 之外，java中还提供了另一个序列化接口Externalizable

为了了解Externalizable接口和Serializable接口的区别，先来看代码，我们把上面的代码改成使用Externalizable的形式。

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

/**
 * 实现Externalizable接口
 */
public class User1 implements Externalizable {

    private String name;
    private int age;

    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;
    }

    public void writeExternal(ObjectOutput out) throws IOException {

    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
package com.hollischaung.serialization.ExternalizableDemos;

import java.io.*;

public class ExternalizableDemo1 {

    //为了便于理解和节省篇幅，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
    //IOException直接抛出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        User1 user = new User1();
        user.setName("hollis");
        user.setAge(23);
        oos.writeObject(user);
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        User1 newInstance = (User1) ois.readObject();
        //output
        System.out.println(newInstance);
    }
}
//OutPut:
//User{name='null', age=0}

通过上面的实例可以发现，对User1类进行序列化及反序列化之后得到的对象的所有属性的值都变成了默认值。也就是说，之前的那个对象的状态并没有被持久化下来。这就是Externalizable接口和Serializable接口的区别：

Externalizable继承了Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()。当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法。由于上面的代码中，并没有在这两个方法中定义序列化实现细节，所以输出的内容为空。还有一点值得注意：在使用Externalizable进行序列化的时候，在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。所以，实现Externalizable接口的类必须要提供一个public的无参的构造器。

按照要求修改之后代码如下：

package com.hollischaung.serialization.ExternalizableDemos;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

/**
 * 实现Externalizable接口,并实现writeExternal和readExternal方法
 */
public class User2 implements Externalizable {

    private String name;
    private int age;

    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;
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
package com.hollischaung.serialization.ExternalizableDemos;

import java.io.*;


public class ExternalizableDemo2 {

    //为了便于理解和节省篇幅，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
    //IOException直接抛出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        User2 user = new User2();
        user.setName("hollis");
        user.setAge(23);
        oos.writeObject(user);
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        User2 newInstance = (User2) ois.readObject();
        //output
        System.out.println(newInstance);
    }
}
//OutPut:
//User{name='hollis', age=23}

这次，就可以把之前的对象状态持久化下来了。

如果User类中没有无参数的构造函数，在运行时会抛出异常：java.io.InvalidClassException

ObjectOutputStream类和ObjectInputStream类

通过前面的代码片段中我们也能知道，我们一般使用ObjectOutputStream的writeObject方法把一个对象进行持久化。再使用ObjectInputStream的readObject从持久化存储中把对象读取出来。

注意：writeObject()方法存储Field的顺序应该和readObject()方法中恢复Field的顺序一致，否则将不能正常恢复该Java对象。

对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的。

如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的?

答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用。

那么，不知道有没有人提出这样的疑问： 

Serializable明明就是一个空的接口，它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢？

Serializable接口的定义：

public interface Serializable {
}

其实这个问题也很好回答，我们再回到刚刚ObjectOutputStream的writeObject的调用栈：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

writeObject0方法中有这么一段代码：

if (obj instanceof String) {
    writeString((String) obj, unshared);
} else if (cl.isArray()) {
    writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
    writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
    writeOrdinaryObject(obj, desc, unshared);
} else {
    if (extendedDebugInfo) {
    throw new NotSerializableException(
    cl.getName() + "\n" + debugInfoStack.toString());
    } else {
    }
}

在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果不是则直接抛出NotSerializableException。

Transient 关键字

Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。Transient 关键字只能用于修饰Field，不可修饰Java程序中的其他成分。

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

序列化ID

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID)

序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

对类的哪些修改可能导致该类实例的反序列化失败呢？下面分三种情况来具体讨论：

如果修改类时仅仅修改了方法，则反序列化不受任何影响，类定义无须修改serialVersionUID Field值；

如果修改类时仅仅修改了静态Field或瞬态Field，则反序列化不受任何影响，类定义无须修改serialVersionUID Field值；

如果修改类时修改了非静态Field、非瞬态Field，则可能导致序列化版本不兼容。如果对象流中的对象和新类中包含同名的Field，而Field类型不同，则反序列化失败，类定义应该更新serialVersionUID Field值。如果对象流中的对象比新类中包含更多的Field，则多出的Field值被忽略，序列化版本可以兼容，类定义可以不更新serialVersionUID Field值；如果新类比对象流中的对象包含更多的Field，则序列化版本也可以兼容，类定义可以不更新serialVersionUID Field值；但反序列化得到的新对象中多出的Field值都是null（引用类型Field）或0（基本类型Field）。

防止序列化破坏单例模式

只要在Singleton类中定义readResolve就可以解决该问题：

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

public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
}

还是运行以下测试类：

package com.hollis;
import java.io.*;
public class SerializableDemo1 {
    //为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
    //Exception直接抛出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(Singleton.getSingleton());
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判断是否是同一个对象
        System.out.println(newInstance == Singleton.getSingleton());
    }
}
//true

本次输出结果为true。主要在Singleton中定义readResolve方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。

所有的单例类、枚举类在实现序列化时都应该提供readResolve()方法，这样才可以保证反序列化的对象依然正常。通常的建议是，对于final类重写readResolve()方法不会有任何问题；否则，重写readResolve()方法时应尽量使用private修饰该方法。

总结：

1、如果一个类想被序列化，需要实现Serializable接口。否则将抛出NotSerializableException异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。

2、在变量声明前加上该关键字，可以阻止该变量被序列化到文件中。

3、在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略。

4、在涉及到序列化的场景时，要格外注意他对单例的破坏。

shuai_li_jun
关注
专栏目录
Java中对象序列化与反序列化详解
09-03
本文将深入探讨Java中的对象序列化与反序列化的概念、原理、实现方法以及相关的注意事项。 **一、对象序列化的概念和作用** 对象序列化是将一个Java对象转换成字节流的过程，这个字节流可以存储在磁盘上，也可以在...
java序列化和反序列化，面试必备
12-21
Java序列化和反序列化是Java开发中常见且重要的概念，尤其在面试中常常被问及。序列化是指将一个Java对象转化为字节序列的过程，这样可以将对象的状态持久化到磁盘上或者在网络中进行传输。反序列化则是相反的过程，...
Java对象序列化详解
chenxudong127的博客
10-17 224
所有分布式应用常常需要跨平台，跨网络，因此要求所有传的参数、返回值都必须实现序列化。 一、定义 　　序列化：把Java对象转换为字节序列的过程。  　　  　　反序列化：把字节序列恢复为Java对象的过程。 二、用途 　　对象的序列化主要有两种用途：  　　  　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；（持久化对象）  　　  　　2）
Java对象的序列化与反序列化
weixin_30723433的博客
05-26 79
序列化的含义和意义 对象序列化的目标是将对象保存到磁盘中，或允许在网络中直接传输对象。对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，通过网络将这种二进制流传输到另一个网络节点。其他程序一旦获得了这种二进制流，都可以将这种二进制流恢复成原来的Java对象。 对象序列化机制（object serialization）是Java语言内建...
java 如何反序列化_Java中如何实现对象的序列化和反序列化？（两种方法）
weixin_36358109的博客
02-16 679
本篇文章给大家带来的内容是关于Java中如何实现对象的序列化和反序列化？(两种方法)，有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。引言：序列化是将对象的状态信息转换为可以存储或传输的形式的过程，在序列化期间，对象将其带你过去的状态写入到临时或持储存区，反序列化就是重新创建对象的过程，此对象来自于临时或持久储存区。序列化的作用：就好比如存储数据到数据库，将一些数据持久化到数据库中，...
Java 对象的序列化
calabash_man的博客
07-13 171
对象的序列化概念应用涉及的接口和类 概念 对象序列化：将对象写到输出流中。 对象反序列化：从输入流中读取对象。 应用 调用远程方法：调用远程方法时，需要在客户机与服务器之间传递对象。 对象的持久性保持：允许对象在创建他们的生命周期结束后仍然保存，供以后程序调用。 涉及的接口和类 对象的序列化必须是：实现接口Serializable的类的对象。 Serializable：是一个空接口，没有语义和字段，仅用于标识可序列化的语义。 序列化的类和方法是：ObjectOutputStream，WriterObject
【java对象序列化】
zhhlk的专栏
11-26 628
对象序列化操作
深入分析Java的序列化与反序列化
12-22
本文通过分析ArrayList的序列化来介绍Java序列化的相关内容。主要涉及到以下几个问题： 　怎么实现Java的序列化 　为什么实现了java.io.Serializable接口才能被序列化 　transient的作用是什么 　怎么自定义序列...
Java对象的序列化和反序列化实践
12-22
　把字节序列恢复为Java对象的过程称为对象的反序列化。 　对象的序列化主要有两种用途： 　1）把对象的字节序列地保存到硬盘上，通常存放在一个文件中； 　2）在网络上传送对象的字节序列。 　一、JDK类库...
java对象序列化与反序列化的默认格式和json格式使用示例
10-26
Jackson库是Java中广泛使用的JSON处理库，它提供了高效且灵活的API进行JSON序列化和反序列化。以下是如何使用Jackson进行操作的例子： ```java import com.fasterxml.jackson.databind.ObjectMapper; // 序列化 ...
Java对象序列化
geshengbin的博客
07-01 203
Java对象序列化的意义在于，可以将Java对象转换成字节数据，保存在磁盘上，或者直接通过网络传播。同时通过反序列化可以把保存在磁盘，或者网络上的java字节数据恢复成原来的对象。所以序列化使Java对象可以脱离程序而独立存在。 Java类实现可序列化的要求是，实现下面的两个接口之一： Serializable Externalizable 一、使用对象流实现序列化 两个步骤实现序列化： 创建ObjectOutputStream处理流 //处理流必须建立在节点流FileOutputStrea
对象序列化_Allione_新浪博客
dsydly的博客
08-22 136
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。 　　只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和...
Java对象的序列化
wang_yong_zhang的博客
02-07 325
简单整理了一下，哈哈，其实是简单抄了点。https://www.cnblogs.com/wxgblogs/p/5849951.html 序列化：把对象转化为可传输的字节序列过程称为序列化。 反序列化：把字节序列还原为对象的过程称为反序列化。 序列化的最终目的是为了对象可以跨平台存储和进行网络传输。跨平台存储和网络传输的方式是IO，而我们的IO支持的数据格式就是字节数组。因为我们单方面的只把对象转成字节数组还不行，因为没有规则的字节数组我们是没办法把对象的本来面目还原回来的，所以我们必须在把对象转成
java对象序列化
bluewaveandy的博客
06-30 105
定义 当一个类实现了Serializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化。序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列,可以把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象。甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只要该计算机平台存在相应的类就可以正常恢复为原来的对象。 实现方法 要序列化一个对象，先要创建某些OutputStream对象，然后将其封装在一个Obje
Java 对象序列化
wangcheng_BI的博客
11-04 824
对象序列化与反序列化
Java中序列化和反序列化是什么意思
最新发布
05-23
Java中的序列化是将对象转换成字节序列的过程，使得对象可以在网络上传输或者保存到本地磁盘中。而反序列化则是将字节序列还原成对象的过程。通过序列化和反序列化，可以方便地进行对象的传输和存储，实现数据的持久化。在Java中，可以通过实现 Serializable 接口来使对象可序列化，同时使用 ObjectInputStream 和 ObjectOutputStream 类来进行序列化和反序列化操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值