面试官：三年工作经验，你连序列化都说不明白？

た入场券 2022-11-03 04:24 190阅读 0赞

## 什么是序列化、反序列化 ##

*  序列化：把Java对象转换为字节序列的过程。
 *  反序列化：把字节序列恢复为Java对象的过程。

## 序列化的作用 ##

*  1、可以把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；（持久化对象）
 *  2、也可以在网络上传输对象的字节序列；（网络传输对象）

## 序列化在Java中的用法 ##

在Java中序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，实现该接口只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象输出流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用ObjectInputStream(对象输入流)。

如下为序列化、反序列化简单案例`Test01`：

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test01 {
        public static void main(String[] args) {
            //序列化操作
            serializable();
            //反序列化操作
            deserialization();
        }
    
        private static void serializable() {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
                Person person = new Person();
                person.setName("张三");
                person.setAge(20);
                oos.writeObject(person);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        private static void deserialization() {
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                Person person = (Person) ois.readObject();
                System.out.println(person);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    //目标类实现Serializable接口
    class Person implements Serializable {
    	private static final long serialVersionUID = -2052381772192998351L;
        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 "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

上面案例中只是简单的进行了对象序列化和反序列化，但是序列化和反序列化过程中有很多值得思考的细节问题，例如：

> 1、序列化版本号（serialVersionUID）问题  
> 2、静态变量序列化  
> 3、父类的序列化与 `transient` 关键字  
> 4、自定义序列化规则  
> 5、序列化存储规则

**1、序列化版本号（serialVersionUID）问题**

在写Java程序中有时我们经常会看到类中会有一个序列化版本号：serialVersionUID。这个值有的类是1L或者是自动生成的。

private static final long serialVersionUID = 1L;

或者

private static final long serialVersionUID = -2052381772192998351L;

当在反序列化时JVM需要判断需要转化的两个类是不是同一个类，于是就需要一个序列化版本号。如果在反序列化的时候两个类的serialVersionUID不一样则JVM会抛出java.io.InvalidClassException的异常；如果serialVersionUID一致则表明可以转换。

如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException，所以这种方式不支持反序列化重构。所谓重构就是可以对类增加或者减少属性字段，也就是说即使两个类并不完全一致，他们也是可以转换的，只不过如果找不到对应的字段，它的值会被设为默认值。

因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性或代码重构时，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 – serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。

还有一个常见的值是1L（或者其他固定值），如果所有类都这么写那还怎么区分它们，这个字段还有什么意义吗？有的！首先如果两个类有了相同的反序列化版本号，比如1L，那么表明这两个类是支持在反序列化时重构的。但是会有一个明显的问题：如果两个类是完全不同的，但是他们的序列化版本号都是1L，那么对于JVM来说他们也是可以进行反序列化重构的！这这显然是不对的，但是回过头来说这种明显的，愚蠢的错误在实际开发中是不太可能会犯的，如果不是那么严谨的话用1L是个不错的选择。

一般的情况下这个值是显式地指定为一个64位的哈希字段，比如你写了一个类实现了java.io.Serializable接口，在idea里会提示你加上这个序列化id。这样做可以区分不同的类，也支持反序列化重构。

总结如下:

<table> 
 <thead> 
  <tr> 
   <th align="left">serialVersionUID</th> 
   <th align="left">区分不同类</th> 
   <th align="left">支持相同类的重构</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">不指定</td> 
   <td align="left">YES</td> 
   <td align="left">NO</td> 
  </tr> 
  <tr> 
   <td align="left">1L</td> 
   <td align="left">NO</td> 
   <td align="left">YES</td> 
  </tr> 
  <tr> 
   <td align="left">64位哈希值</td> 
   <td align="left">YES</td> 
   <td align="left">YES</td> 
  </tr> 
 </tbody> 
</table>

简单而言，从严谨性的角度来说，指定64位哈希值>默认值1L>不指定serialVersionUID值，具体怎么使用就看你的需求啦。

**2、静态变量序列化**

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test02 {
        public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
                 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                //初始时avgAge为77
                Person person = new Person();
                person.setName("张三");
                person.setAge(20);
                oos.writeObject(person);
    
                //序列化后修改avgAge为80
                Person.avgAge = 80;
    
                Person person1 = (Person) ois.readObject();
                //再读取，通过person1.avgAge输出新的值，通过实例对象访问静态变量本来就很反常
                System.out.println(person1.avgAge);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    //目标对象实现Serializable接口
    class Person implements Serializable {
        private static final long serialVersionUID = -2052381772192998351L;
        private String name;
        private int age;
        public static int avgAge = 77;
    
        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 "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

执行结果显示如下：

![dd9010e204bbca1877946e6a7647e75d.png][]

我们看到`Test02.java`将对象序列化后，修改静态变量的数值再将序列化对象读取出来，然后通过读取出来的对象获得静态变量的数值并打印出来，最后的输出是 10，之所以打印 10 的原因在于序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量 。

**3、父类的序列化与`transient`关键字**

情境 ：一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，该变量数值与序列化时的数值不同。

解决 ： 要想将父类对象也序列化，就需要让父类也实现 Serializable 接口 。如果父类不实现的话的，就需要有默认的无参的构造函数 。在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

**3-1、特性使用案例：**

我们熟悉使用 transient 关键字可以使得字段不被序列化，那么还有别的方法吗？根据父类对象序列化的规则，我们可以将不需要被序列化的字段抽取出来放到父类中，子类实现 Serializable 接口，父类不实现，根据父类序列化规则，父类的字段数据将不被序列化，形成类图如下图所示。

![be7857f8a2e47b14de83de2f32f41ad0.gif][]

上图中可以看出，attr1、attr2、attr3、attr5 都不会被序列化，放在父类中的好处在于当有另外一个 Child 类时，attr1、attr2、attr3 依然不会被序列化，不用重复书写 transient 关键字，代码简洁。

**4、自定义序列化规则**

在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

private void writeObject(java.io.ObjectOutputStream oos) throws IOException;
     private void readObject(java.io.ObjectInputStream oin) throws IOException, ClassNotFoundException;
     private void readObjectNoData() throws ObjectStreamException;

writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以恢复它。通过调用 oos.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream，状态可以被保存。

readObject 方法负责从流中读取并恢复类字段。它可以调用 oin.defaultReadObject 来调用默认机制，以恢复对象的非静态和非瞬态(非 transient 修饰)字段。defaultReadObject方法使用流来分配保存在流中的对象的字段当前对象中相应命名的字段。这用于处理类演化后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream，状态可以被保存。

在序列化流不列出给定类作为将被反序列化对象的超类的情况下，readObjectNoData 方法负责初始化特定类的对象状态。这在接收方使用的反序列化实例类的版本不同于发送方，并且接收者版本扩展的类不是发送者版本扩展的类时发生。在序列化流已经被篡改时也将发生；因此，不管源流是“敌意的”还是不完整的，readObjectNoData 方法都可以用来正确地初始化反序列化的对象。

readObjectNoData()应用示例：

import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    //先对旧的类对象进行序列化
    public class Test03Old {
        public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
                Person person = new Person();
                person.setAge(20);
                oos.writeObject(person);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    class Person implements Serializable {
        private int age;
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public int getAge() {
            return this.age;
        }
    }

--------------------

import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    import java.io.Serializable;
    
    //用新的类规范来反序列化
    public class Test03New {
        public static void main(String[] args) {
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                Person person = (Person) ois.readObject();
                System.out.println(person.getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    //新的类继承了Animal，这是已经序列化的旧对象里面所没有的内容，
    //所以实现readObjectNoData，可以弥补这种因临时扩展而无法兼容反序列化的缺陷
    class Person extends Animal implements Serializable {
        private int age;
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public int getAge() {
            return this.age;
        }
    }
    
    class Animal implements Serializable {
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return this.name;
        }
    
        private void readObjectNoData() {
            this.name = "张三";
        }
    }

将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。

在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

**TIP：** readResolve常用来反序列单例类，保证单例类的唯一性

例如：

答案很显然是false，因为Brand.NIKE是程序中创建的对象，而b是从磁盘中读取并恢复过来的对象，两者明显来源不同，因此必然内存空间是不同的，引用（地址）显然也是不同的；

但这不是我们想看到的，因为我们把Brand设计成枚举类型，不管是程序中创建的还是从哪里读取的，其必须应该和枚举常量完全相等，这才是枚举的意义啊！

--------------------

而此时readResolve就派上用场了，我们可以这样实现readResolve:

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.ObjectStreamException;
    import java.io.Serializable;
    
    public class Test04New {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
                oos.writeObject(Brand.NIKE);
            }
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                Brand b = (Brand) ois.readObject();
                // 答案显然是true
                System.out.println(b == Brand.NIKE);
            }
        }
    }
    
    class Brand implements Serializable {
        private int val;
    
        private Brand(int val) {
            this.val = val;
        }
    
        // 两个枚举值
        public static final Brand NIKE = new Brand(0);
        public static final Brand ADDIDAS = new Brand(1);
    
        private Object readResolve() throws ObjectStreamException {
            if (val == 0) {
                return NIKE;
            }
            if (val == 1) {
                return ADDIDAS;
            }
            return null;
        }
    }

改造以后，不管来源如何，最终得到的都将是程序中Brand的枚举值了！因为readResolve的代码在执行时已经进入了程序内存环境，因此其返回的NIKE和ADDIDAS都将是Brand的静态成员对象；

因此保护性恢复的含义就在此：首先恢复的时候没有改变其值（val的值没有改变）同时恢复的时候又能正常实现枚举值的对比（地址也完全相同）；

**4-1、对敏感字段加密**

情境：服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

解决：在序列化过程中，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化，该方法必须要被声明为private，如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作，如下代码展示了这个过程。

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test05 {
        public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
                 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                oos.writeObject(new Account());
    
                Account account = (Account) ois.readObject();
                System.out.println("解密后的字符串:" + account.getPassword());
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    class Account implements Serializable {
        private String password = "123456";
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        private void writeObject(ObjectOutputStream out) {
            try {
                ObjectOutputStream.PutField putFields = out.putFields();
                System.out.println("原密码:" + password);
                //模拟加密
                password = "encryption";
                putFields.put("password", password);
                System.out.println("加密后的密码" + password);
                out.writeFields();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        private void readObject(ObjectInputStream in) {
            try {
                ObjectInputStream.GetField readFields = in.readFields();
                Object object = readFields.get("password", "");
                System.out.println("要解密的字符串:" + object.toString());
                //模拟解密,需要获得本地的密钥
                password = "123456";
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

上述代码中的 writeObject 方法中，对密码进行了加密，在 readObject 中则对 password 进行解密，只有拥有密钥的客户端，才可以正确的解析出密码，确保了数据的安全。执行上述代码后控制台输出如下图所示。

![4089ddbadc23a6a808232f432f32a47c.png][]

**4-2、序列化SDK中不可序列化的类型**

`4-1、对敏感字段加密`案例使用 writeObject 和 readObject 进行了对象属性值加解密操作，有时我们想将对象中的某一字段序列化，但它在SDK中的定义却是不可序列化的类型，这样的话我们也必须把他标注为 transient 才能保证正常序列化，可是不能序列化又怎么恢复呢？这就用到了上面提到的 writeObject 和 readObject 方法，进行自定义序列化操作了。

示例：java.awt.geom包中的Point2D.Double类就是不可序列化的，因为该类没有实现Serializable接口

import java.awt.geom.Point2D;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test06 {
        public static void main(String[] args) {
            LabeledPoint label = new LabeledPoint("Book", 5.00, 5.00);
            try {
                // 写入前
                System.out.println(label);
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.txt"));
                //通过对象输出流，将label写入流中
                out.writeObject(label);
                out.close();
                // 写入后
                System.out.println(label);
                ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.txt"));
                LabeledPoint label1 = (LabeledPoint) in.readObject();
                in.close();
                // 读出并加1.0后
                System.out.println(label1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    class LabeledPoint implements Serializable {
        private String label;
        //因为不可被序列化，所以需要加transient关键字
        transient private Point2D.Double point;
    
        public LabeledPoint(String str, double x, double y) {
            label = str;
            //此类Point2D.Double不可被序列化
            point = new Point2D.Double(x, y);
        }
    
        //因为Point2D.Double不可被序列化，所以需要实现下面两个方法
        private void writeObject(ObjectOutputStream oos) throws IOException {
            oos.defaultWriteObject();
            oos.writeDouble(point.getX());
            oos.writeDouble(point.getY());
        }
    
        private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
            ois.defaultReadObject();
            double x = ois.readDouble() + 1.0;
            double y = ois.readDouble() + 1.0;
            point = new Point2D.Double(x, y);
        }
    
        @Override
        public String toString() {
            return "LabeledPoint{" +
                    "label='" + label + '\'' +
                    ", point=" + point +
                    '}';
        }
    }

执行结果如图所示：

![0a0bcf5c962d279e9397c4fb643fcca0.png][]

在`4-1、序列化SDK中不可序列化的类型`案例中，你会发现调用了defaultWriteObject()和defaultReadObject()。它们做的是默认的序列化进程，就像写/读所有的non-transient和 non-static字段(但他们不会去做serialVersionUID的检查)。通常说来，所有我们想要自己处理的字段都应该声明为transient。这样的话 defaultWriteObject/defaultReadObject 便可以专注于其余字段，而我们则可为这些特定的字段(指transient)定制序列化。使用那两个默认的方法并不是强制的，而是给予了处理复杂应用时更多的灵活性。

**5、序列化存储规则**

**5-1、存储两次相同对象**

import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test07 {
        public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
                 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
                //试图将对象两次写入文件
                Account account = new Account();
                account.setPassword("123456");
                oos.writeObject(account);
                oos.flush();
                System.out.println(new File("object.txt").length());
                oos.writeObject(account);
                System.out.println(new File("object.txt").length());
    
                //从文件依次读出两个对象
                Account account1 = (Account) ois.readObject();
                Account account2 = (Account) ois.readObject();
    
                //判断两个引用是否指向同一个对象
                System.out.println(account1 == account2);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    class Account implements Serializable {
        private String password;
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }

上述代码中对同一对象两次写入文件，打印出写入一次对象后的存储大小和写入两次后的存储大小，然后从文件中反序列化出两个对象，比较这两个对象是否为同一对象。一般的思维是，两次写入对象，文件大小会变为两倍的大小，反序列化时，由于从文件读取，生成了两个对象，判断相等时应该是输入 false 才对，但是最后结果输出如图下图所示。

![7bb32bed991c83a94a595748c11781a2.png][]

我们看到，第二次写入对象时文件只增加了 5 字节，并且两个对象是相等的，因为Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得上述代码中的 account1 和 account2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间

**5-2、存储两次相同对象，更改属性值**

执行结果如下图：  
![46e43624f1002f3e89fd4b99ba5b595f.png][]

上述代码的目的是希望将 account 对象两次保存到 object.txt 文件中，写入一次以后修改对象属性值再次保存第二次，然后从 object.txt 中再依次读出两个对象，输出这两个对象的 password 属性值。上述代码的目的原本是希望一次性传输对象修改前后的状态。

结果两个输出的都是 123456， 原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。这也验证了`5-1、存储两次相同对象`案例的现象，相同对象存在只会存储引用，不再进行对象存储，所以第二次修改的属性未变化。读者在使用一个文件多次 writeObject 需要特别注意这个问题。

[dd9010e204bbca1877946e6a7647e75d.png]: /images/20221024/e285c298ed1b4a48b8b544fc0826010f.png
[be7857f8a2e47b14de83de2f32f41ad0.gif]: /images/20221024/2843782fc0ae46a28fa1c0a09ea62782.png
[4089ddbadc23a6a808232f432f32a47c.png]: /images/20221024/8691473f947b470da5a20c86cb0d6630.png
[0a0bcf5c962d279e9397c4fb643fcca0.png]: /images/20221024/77afa8b9e3e34f3d82f11178cd2f1b40.png
[7bb32bed991c83a94a595748c11781a2.png]: /images/20221024/770930e24b68494f80477ca0d45aed4f.png
[46e43624f1002f3e89fd4b99ba5b595f.png]: /images/20221024/190662c801ad42c98d8f0974981f0787.png