Java序列化与反序列化 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，各位观众，各位朋友，欢迎来到今天的“Java序列化与反序列化奇妙之旅”！我是你们的向导，外号“代码诗人”，今天就带大家深入这片神秘又充满乐趣的领域。

准备好了吗？让我们系好安全带，开始这趟精彩的探险吧！🚀

一、故事的开端：对象也想“搬家”？

想象一下，你精心制作了一个乐高城堡🏰，每个积木都倾注了你的心血。现在，你想把这个城堡“搬”到另一个房间，甚至另一个城市。直接搬？太麻烦！说不定半路就散架了。

这时候，你就需要一种神奇的技术，能把城堡“打包”成一个方便运输的“包裹”，到了目的地再原封不动地“展开”出来。

在Java世界里，这个“打包”的过程就是序列化 (Serialization)，而“展开”的过程就是反序列化 (Deserialization)。

简单来说，序列化就是将Java对象转换成字节流的过程，而反序列化则是将字节流转换回Java对象的过程。

二、为什么要让对象“搬家”？—— 序列化的应用场景

你可能会问：“好端端的对象，为什么要让它搬家呢？” 嗯，问得好！对象“搬家”的需求可不少呢：

网络传输： 在网络通信中，数据只能以字节流的形式传输。如果想通过网络发送一个Java对象，就需要先将它序列化成字节流，接收方收到字节流后再反序列化成Java对象。这就像把你的乐高城堡压缩成一个ZIP文件，通过邮件发送给远方的朋友，朋友收到后解压就能看到完整的城堡了。
持久化存储： 有时候，我们需要将Java对象的状态保存到磁盘或其他存储介质中，以便以后可以恢复。序列化可以将对象转换成字节流，方便存储到文件中；反序列化则可以将文件中的字节流还原成Java对象。这就像把你的乐高城堡拍照存起来，以后想玩的时候再拿出来“复原”。
分布式系统： 在分布式系统中，不同的节点可能需要共享Java对象。通过序列化和反序列化，可以将对象在不同的节点之间传递。

应用场景	描述	示例
网络传输	将Java对象转换为字节流，以便在网络中传输。	比如，使用Socket进行网络编程时，需要将Java对象序列化后才能发送到对方。
持久化存储	将Java对象的状态保存到磁盘或其他存储介质中，以便以后可以恢复。	比如，将用户的信息保存到数据库中，或者将游戏的进度保存到文件中。
分布式系统	在分布式系统中，不同的节点可能需要共享Java对象。通过序列化和反序列化，可以将对象在不同的节点之间传递。	比如，使用RMI（Remote Method Invocation）进行远程方法调用时，需要将参数和返回值序列化后才能在不同的JVM之间传递。
Session复制	在Web应用中，为了保证Session的可靠性，通常会将Session复制到多个服务器上。Session中的对象需要实现序列化接口，才能在不同的服务器之间复制。	比如，在Tomcat集群中，Session可以被复制到不同的Tomcat服务器上，从而保证用户的登录状态不会因为服务器宕机而丢失。
缓存	在缓存系统中，通常会将Java对象序列化后存储到缓存中，以便以后可以快速访问。	比如，使用Redis或Memcached作为缓存时，需要将Java对象序列化后才能存储到缓存中。

三、如何让对象“搬家”？—— Serializable 接口

在Java中，要让一个类的对象可以序列化，只需要让该类实现 java.io.Serializable 接口即可。

import java.io.Serializable;

public class MyObject implements Serializable {
    private String name;
    private int age;

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

    // Getters and setters...

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

注意： Serializable 接口是一个标记接口，它没有任何方法需要实现。它的作用仅仅是告诉JVM，这个类的对象是可以序列化的。

四、 “打包”和“展开”的过程：ObjectOutputStream 和 ObjectInputStream

有了 Serializable 接口，我们就可以使用 ObjectOutputStream 和 ObjectInputStream 类来进行序列化和反序列化操作了。

1. 序列化 (打包)：

import java.io.*;

public class SerializationExample {
    public static void main(String[] args) {
        MyObject obj = new MyObject("Alice", 30);

        try (FileOutputStream fileOut = new FileOutputStream("myobject.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {

            out.writeObject(obj);
            System.out.println("对象已序列化到 myobject.ser");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这段代码就像是把你的乐高城堡小心翼翼地装进一个密封的箱子里，然后贴上标签“myobject.ser”。

2. 反序列化 (展开)：

import java.io.*;

public class DeserializationExample {
    public static void main(String[] args) {
        MyObject obj = null;

        try (FileInputStream fileIn = new FileInputStream("myobject.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {

            obj = (MyObject) in.readObject();
            System.out.println("对象已从 myobject.ser 反序列化");
            System.out.println(obj);

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

这段代码就像是打开贴有“myobject.ser”标签的箱子，小心翼翼地取出里面的乐高城堡，然后把它摆放到原来的位置。

五、序列化ID：身份的象征，版本的守护者

每个可序列化的类都有一个唯一的序列化ID (serialVersionUID)。这个ID就像是乐高城堡的身份证号码，用于标识不同的城堡版本。

为什么要指定序列化ID？

版本兼容性： 如果在序列化之后修改了类的结构（例如，添加或删除字段），反序列化时可能会出现问题。通过指定 serialVersionUID，可以显式地控制版本兼容性。
避免自动生成： 如果没有显式地指定 serialVersionUID，JVM会根据类的结构自动生成一个。但是，如果类的结构发生变化，自动生成的 serialVersionUID 也会发生变化，导致反序列化失败。

如何指定序列化ID？

import java.io.Serializable;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;  // 显式指定序列化ID
    private String name;
    private int age;

    // ...
}

建议： 强烈建议为每个可序列化的类显式地指定 serialVersionUID。

六、 Transient 关键字：有些秘密，不宜公开

有时候，有些字段是不希望被序列化的。例如，密码、敏感数据等。这时，可以使用 transient 关键字来标记这些字段。

import java.io.Serializable;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password;  // 密码不参与序列化

    // ...
}

被 transient 关键字标记的字段，在序列化时会被忽略，反序列化后会被设置为默认值（例如，null 或 0）。这就像是给你的乐高城堡加了一个秘密隔间，里面放着一些不想让别人看到的东西，在“打包”的时候，这个隔间会被隐藏起来。

七、 Externalizable 接口：我的地盘，我做主

除了 Serializable 接口，Java还提供了 Externalizable 接口，它允许你完全控制序列化和反序列化的过程。

import java.io.*;

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

    public MyObject() {
        // 必须提供一个无参构造函数
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 自定义序列化逻辑
        out.writeObject(name);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 自定义反序列化逻辑
        name = (String) in.readObject();
        age = in.readInt();
    }

    // ...
}

注意：

实现 Externalizable 接口的类必须提供一个无参构造函数。
需要自己实现 writeExternal() 和 readExternal() 方法，来控制序列化和反序列化的过程。

Externalizable 接口就像是给你提供了一个工具箱，你可以自己选择哪些积木要“打包”，以及如何“打包”。

八、序列化与继承：血脉相承，薪火相传

当一个类继承了实现了 Serializable 接口的父类时，子类也会自动继承序列化的能力。

但是，如果父类没有实现 Serializable 接口，子类实现了，那么只有子类自己的字段会被序列化，父类的字段不会被序列化。

九、序列化的坑：小心踩雷，安全第一

序列化虽然强大，但也存在一些潜在的风险：

安全漏洞： 反序列化可以执行任意代码，如果反序列化的数据被恶意篡改，可能会导致安全漏洞。
性能问题： 序列化和反序列化会消耗一定的性能，特别是对于复杂的对象。
版本兼容性问题： 如果在序列化之后修改了类的结构，反序列化时可能会出现问题。

如何避免这些坑？

谨慎使用反序列化： 尽量避免反序列化不受信任的数据。
使用安全的序列化方式： 例如，使用JSON或其他更安全的序列化格式。
注意版本兼容性： 在修改类的结构时，要考虑到版本兼容性问题。

十、总结：序列化，让对象飞起来

序列化和反序列化是Java中非常重要的概念，它们可以帮助我们实现对象的网络传输、持久化存储和分布式共享。

Serializable 接口：让对象拥有“搬家”的能力。
ObjectOutputStream 和 ObjectInputStream：实现“打包”和“展开”的过程。
serialVersionUID：身份的象征，版本的守护者。
transient 关键字：有些秘密，不宜公开。
Externalizable 接口：我的地盘，我做主。

希望今天的“Java序列化与反序列化奇妙之旅”能让你对这个领域有更深入的了解。记住，代码的世界充满了乐趣，让我们一起探索，一起成长！

谢谢大家！🎉

发表回复 取消回复

发表回复取消回复