揭开Java序列化的神秘面纱（上）Serializable使用详解

最新推荐文章于 2024-07-21 22:27:18 发布

w风雨无阻w

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量1k

点赞数 20

分类专栏： java 文章标签： java 序列化性能优化

本文链接：https://blog.csdn.net/lizhong2008/article/details/139107889

版权

java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Java序列化(Serialization)作为一项核心技术，在Java应用程序的多个领域都有着广泛的应用。无论是通过网络进行对象传输，还是实现对象的持久化存储，序列化都扮演着关键的角色。然而，这个看似简单的概念蕴含着丰富的原理和用法细节，值得我们一探究竟。

一、序列化的本质

序列化的本质是将对象转换为字节流，以便在网络上传输或存储在磁盘上。经过序列化后，虚拟机中的对象便可以脱离运行环境，转化为平台无关的原始字节流，方便进行传输和持久化。

Serializable序列化的本质可以从以下几个方面来理解：

对象状态的保存：序列化允许将对象的状态（即对象的字段值）保存到一个持久化存储中，例如文件或数据库。这意味着即使程序停止运行，对象的状态也可以被保存下来，并在需要时重新加载。
对象的传输：在分布式系统中，对象序列化可以用于通过网络传输对象。通过网络发送对象的序列化形式，然后在接收端进行反序列化，从而恢复对象的状态。
跨平台：序列化允许Java对象在不同的平台和Java虚拟机之间传输。只要序列化和反序列化的过程遵循相同的协议，对象就可以在不同的系统上保持一致。
兼容性：Java的序列化机制保证了对象的兼容性。即使类的实现发生了变化，只要类的序列化版本号（serialVersionUID）保持不变，旧的序列化对象仍然可以在新的类实现上进行反序列化。
简单性：实现序列化非常简单。开发者只需要声明类实现了Serializable接口，然后Java运行时环境就会自动处理对象的序列化和反序列化。
性能考虑：序列化和反序列化的过程可能会涉及到大量的I/O操作，这可能会影响程序的性能。因此，对于性能敏感的应用，需要仔细考虑序列化的使用。
安全性：序列化可能会带来安全风险，因为恶意的序列化数据可以被用来执行攻击。因此，需要对序列化的数据进行验证，确保它们是安全和可信的。
自定义序列化：Java允许开发者通过实现ObjectOutputStream和ObjectInputStream的自定义版本来控制序列化和反序列化的过程。这可以用于优化性能或添加额外的序列化逻辑。
非静态字段：只有对象的非静态字段会被序列化。静态字段和方法不会被包含在序列化的数据中。
序列化代理：Java提供了一种机制，称为序列化代理（writeReplace和readResolve方法），允许开发者控制序列化和反序列化过程中对象的替换。

序列化是Java中一个强大的特性，它使得对象可以在不同的环境和平台之间移动，同时也为对象的持久化提供了支持。然而，在使用序列化时也需要考虑到性能、安全性和兼容性等问题。

二、实现Serializable接口

在Java中，实现Serializable接口非常简单，因为这是一个标记接口，它不包含任何方法。要使一个类可序列化，你只需要声明它实现了Serializable接口。

下面是一个简单的Java类实现Serializable接口的示例：

import java.io.Serializable;

public class Person implements Serializable {
    // 定义一个序列化版本号，建议添加，以确保序列化兼容性
    private static final long serialVersionUID = 1L;

    // 可以添加一些字段，这些字段将会被序列化
    private String name;
    private int age;
    private transient String password; // transient关键字表示该字段不会被序列化

    // 构造函数
    public Person(String name， int age， String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }

    // getter和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;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    // 重写toString方法，方便打印对象信息
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                "， age=" + age +
                "， password='" + password + '\'' +
                '}';
    }
    
    // 可以添加其他业务逻辑代码
}

在上面的代码中，`Person`类实现了`Serializable`接口，这意味着`Person`对象可以被序列化和反序列化。

serialVersionUID是一个可选的静态字段，用于在反序列化过程中确保发送方和接收方的序列化版本兼容。如果类实现Serializable接口，建议添加这个字段。

transient关键字用于指示某些字段在序列化过程中应该被忽略。在上面的例子中，password字段被标记为transient，这意味着在序列化Person对象时，密码字段不会被包含在序列化的数据中。

这个类还包含了一些基本的getter和setter方法，以及一个重写的toString方法，用于提供类的字符串表示，这在调试和日志记录时非常有用。

三、序列化和反序列化的流程

序列化的核心是通过ObjectOutputStream和ObjectInputStream来完成。

序列化过程:

创建一个ObjectOutputStream
调用writeObject方法输出可序列化对象

反序列化过程:

创建一个ObjectInputStream
调用readObject方法从流中读取字节，反序列化为对象

下面是一个简单的示例，演示如何序列化和反序列化Person对象：

import java.io.*;

public class SerializationDemo {
    public static void main(String[] args) {
        try {
            // 创建Person对象
            Person person = new Person("John Doe"， 30， "securepassword123");

            // 序列化
            FileOutputStream fileOut = new FileOutputStream("person.ser");
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            out.writeObject(person);
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved in 'person.ser'");

            // 反序列化
            FileInputStream fileIn = new FileInputStream("person.ser");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            Person deserializedPerson = (Person) in.readObject();
            in.close();
            fileIn.close();
            System.out.println("Deserialized Person: " + deserializedPerson);

        } catch (IOException i) {
            i.printStackTrace();
        } catch (ClassNotFoundException c) {
            System.out.println("Person class not found");
            c.printStackTrace();
        }
    }
}

这段代码首先创建了一个`Person`对象，然后使用`ObjectOutputStream`将其序列化到一个文件中。之后，使用`ObjectInputStream`从文件中反序列化对象，并打印出来。注意，反序列化时需要处理`ClassNotFoundException`，这可能发生在找不到要反序列化的类定义时。

四、transient关键字

transient关键字在Java中用于控制序列化行为。当一个类实现了Serializable接口，所有的非静态字段（即实例字段）默认都会被序列化。然而，有些字段可能不适合被序列化，或者序列化这些字段没有意义，这时就可以使用transient关键字来标记这些字段。

1、transient关键字详解：

字段不序列化：被transient关键字标记的字段在对象序列化时不会被保存到序列化的数据中。这意味着在反序列化时，这些字段将保持默认值（例如，null对于对象引用，0对于整数类型）。
默认值恢复：反序列化后，transient字段将被自动恢复为该类型的默认值。
非静态：transient关键字只能用于类的非静态字段。
非继承：transient关键字的效果仅限于声明它的类。如果一个子类继承了一个父类，并且父类中的字段被标记为transient，那么在子类的序列化过程中，这些字段仍然不会被序列化。
性能优化：对于大对象或者包含大量数据的字段，使用transient可以减少序列化的数据量，从而提高序列化和反序列化的效率。

2、使用最佳实践

安全性：对于敏感信息，如密码或个人信息，使用transient可以防止这些信息在序列化过程中被泄露。
资源管理：对于文件句柄、数据库连接、线程等资源，不应该被序列化，因为它们通常与特定的运行时环境相关联，并且可能在序列化后不再有效。
性能考虑：如果一个字段很大，并且不需要在序列化后保留其状态，使用transient可以减少序列化的数据量，提高性能。
临时状态：如果一个字段仅用于临时状态，如缓存或中间计算结果，使用transient可以避免在序列化过程中包含这些不必要的状态。
自定义序列化：对于需要特殊序列化逻辑的字段，可以通过实现writeObject和readObject方法，并在这些方法中显式处理transient字段。
版本控制：在类结构发生变化时，使用transient可以帮助管理字段的版本，避免因为字段的添加或删除导致序列化版本号的变更。
避免不必要的序列化：如果一个字段总是可以通过其他方式重建（例如，基于其他字段的计算），则没有必要序列化它。
文档和维护：在使用transient关键字时，应该在代码中添加适当的注释，说明为什么该字段被标记为transient，以便于其他开发者理解和维护。

通过遵循这些最佳实践，可以有效地利用transient关键字来控制序列化过程，提高应用程序的性能和安全性。

五、自定义序列化逻辑

自定义序列化逻辑允许开发者控制对象序列化和反序列化的详细过程。在Java中，可以通过重写对象类的writeObject和readObject方法来实现自定义序列化。这对于优化性能、处理非可序列化对象、实现版本控制或添加额外的逻辑非常有用。

1、自定义序列化步骤：

第一步，重写writeObject方法：

这个方法是在对象序列化时被调用的。
可以在这里添加自定义的序列化逻辑，比如只序列化对象的某些字段，或者在序列化之前进行某些计算或检查。

第二步，重写readObject方法：

这个方法是在对象反序列化时被调用的。
可以在这里添加自定义的反序列化逻辑，比如在反序列化后恢复对象的状态，或者在对象状态被读取之后执行某些操作。

第三步，使用private void readObject(ObjectInputStream in)和private void writeObject(ObjectOutputStream out)：

这些方法是私有的，只能在类的内部被调用。
它们不能被类的外部调用，这保证了序列化和反序列化过程的安全性。

### 2、示例代码：

import java.io.*;

class MyObject implements Serializable {
    private int value;
    private transient int transientValue;

    public MyObject(int value) {
        this.value = value;
        this.transientValue = 0;
    }

    // 自定义序列化逻辑
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject(); // 序列化非transient字段
        // 可以添加额外的序列化逻辑
        out.writeInt(transientValue + 100); // 示例：修改transient字段的值
    }

    // 自定义反序列化逻辑
    private void readObject(ObjectInputStream in) throws IOException， ClassNotFoundException {
        in.defaultReadObject(); // 反序列化非transient字段
        // 可以添加额外的反序列化逻辑
        transientValue = in.readInt() - 100; // 示例：根据序列化逻辑恢复transient字段的值
    }

    // 其他业务逻辑...
}

3、自定义序列化的最佳实践：

（1）、使用defaultWriteObject和defaultReadObject：

在writeObject和readObject方法中，首先调用defaultWriteObject()和defaultReadObject()方法，以确保非transient字段被正确序列化和反序列化。

（2）、处理transient字段：

如果类中有transient字段，需要在writeObject和readObject方法中显式处理这些字段的序列化和反序列化。

（3）、异常处理：

在自定义序列化方法中，适当处理可能发生的异常，如IOException。

（4）、版本控制：

当类的字段发生变化时，通过在readObject方法中添加逻辑来处理旧版本的序列化对象。

（5）、安全性：

由于writeObject和readObject方法是私有的，确保它们不会被外部调用，避免安全风险。

（6）、性能优化：

优化自定义序列化逻辑，以减少不必要的I/O操作，提高性能。

（7）、测试：

彻底测试自定义序列化逻辑，确保序列化和反序列化过程的正确性和稳定性。

通过实现自定义序列化逻辑，开发者可以更细致地控制对象的序列化过程，满足特定的需求，如安全性、性能优化或复杂的状态管理。

六、版本控制serialVersionUID

在Java序列化机制中，serialVersionUID是一个非常重要的概念，它用于在序列化和反序列化过程中确保类的版本兼容性。以下是关于serialVersionUID的详细说明：

### 1、什么是`serialVersionUID`？

serialVersionUID是一个唯一的版本标识符，用于区分序列化的对象属于哪个类的不同版本。当一个对象被序列化时，它的类定义中的serialVersionUID会被包含在序列化数据中。在反序列化时，Java运行时环境会检查序列化数据中的serialVersionUID与类定义中的serialVersionUID是否匹配。

2、为什么需要`serialVersionUID`？

（1）、版本控制：当类的实现发生变化时（例如，添加或删除字段），serialVersionUID帮助确保类的序列化版本是否兼容。

（2）、反序列化兼容性：如果序列化对象的类定义与反序列化时的类定义不匹配，Java运行时环境会根据serialVersionUID来判断是否可以安全地进行反序列化。

（3）、避免序列化错误：如果没有显式声明serialVersionUID，Java运行时环境会基于类的细节自动生成一个。如果类的实现发生变化，自动生成的serialVersionUID也会变化，这可能导致反序列化时出现InvalidClassException错误。

3、如何使用`serialVersionUID`？

（1）、声明serialVersionUID：

private static final long serialVersionUID = 1L;

这个声明应该放在类的第一行，作为一个静态常量。

（2）、选择serialVersionUID的值：

通常，serialVersionUID是一个长整型（long）值。
可以手动指定一个固定的值，或者使用工具（如serialver工具）来生成。

（3）、更新serialVersionUID：

当类的序列化状态发生变化时（例如，添加、删除或修改字段），应该更新serialVersionUID。
如果希望保持与旧版本的兼容性，可以选择不更新serialVersionUID。

4、最佳实践：

（1）、显式声明：即使类的实现没有变化，也建议显式声明serialVersionUID，以避免自动生成的值在未来发生变化。

（2）、版本管理：在类文档中记录serialVersionUID的更改，以及每次更改的原因。

（3）、兼容性考虑：在设计可序列化的类时，考虑未来可能的变更，并评估这些变更对序列化兼容性的影响。

（4）、使用工具：可以使用serialver工具来帮助生成serialVersionUID。

（5）、测试：在更改类的实现后，彻底测试序列化和反序列化过程，确保serialVersionUID的更改不会破坏现有功能。

（6）、文档化：在类文档中清楚地说明serialVersionUID的使用和任何相关的版本兼容性问题。

通过正确使用serialVersionUID，可以有效地管理类的序列化版本，确保序列化和反序列化过程的兼容性和稳定性。这对于维护大型系统和长期运行的应用程序尤为重要。

总之，Java序列化封装了对象转字节流的细节，提供了简洁的API，但同时也需要我们对其原理和用法有更深入的理解，才能在实践中发挥其最大价值。

期待在未来的技术进化中，序列化会变得更加易于使用和扩展，为分布式系统、大数据处理等领域贡献新的引擎。让我们拭目以待吧!

w风雨无阻w

关注

20
点赞
踩
30

收藏

觉得还不错? 一键收藏
打赏
0
评论
揭开Java序列化的神秘面纱（上）Serializable使用详解

自定义序列化逻辑允许开发者控制对象序列化和反序列化的详细过程。在Java中，可以通过重写对象类的和readObject方法来实现自定义序列化。这对于优化性能、处理非可序列化对象、实现版本控制或添加额外的逻辑非常有用。第一步，重写方法这个方法是在对象序列化时被调用的。可以在这里添加自定义的序列化逻辑，比如只序列化对象的某些字段，或者在序列化之前进行某些计算或检查。第二步，重写readObject方法这个方法是在对象反序列化时被调用的。
复制链接

扫一扫