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

时间  2021-03-02
标签 java 数组 安全 服务器 网络 ide 函数 this 加密 idea 栏目 快乐工作 繁體版
原文   原文链接

什么是序列化、反序列化

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

序列化的做用

  • 一、能够把对象的字节序列永久地保存到硬盘上，一般存放在一个文件中；（持久化对象）
  • 二、也能够在网络上传输对象的字节序列；（网络传输对象）

序列化在Java中的用法

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

以下为序列化、反序列化简单案例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 +
                '}';
    }
}

上面案例中只是简单的进行了对象序列化和反序列化，可是序列化和反序列化过程当中有不少值得思考的细节问题，例如：安全

一、序列化版本号（serialVersionUID）问题
二、静态变量序列化
三、父类的序列化与 transient 关键字
四、自定义序列化规则
五、序列化存储规则服务器

一、序列化版本号（serialVersionUID）问题网络

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

　　private static final long serialVersionUID = 1L;

或者函数

　　private static final long serialVersionUID = -2052381772192998351L;

当在反序列化时JVM须要判断须要转化的两个类是否是同一个类，因而就须要一个序列化版本号。若是在反序列化的时候两个类的serialVersionUID不同则JVM会抛出java.io.InvalidClassException的异常；若是serialVersionUID一致则代表能够转换。this

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

所以，为保证 serialVersionUID 值跨不一样 java 编译器实现的一致性或代码重构时，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（若是可能），缘由是这种声明仅应用于直接声明类 — serialVersionUID 字段做为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，所以它们老是具备默认的计算值，可是数组类没有匹配 serialVersionUID 值的要求。idea

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

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

总结以下:

serialVersionUID 区分不一样类 支持相同类的重构
不指定 YES NO
1L NO YES
64位哈希值 YES YES

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

二、静态变量序列化

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

执行结果显示以下：

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

三、父类的序列化与transient关键字

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

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

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

3-一、特性使用案例：

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

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

四、自定义序列化规则

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

 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经常使用来反序列单例类，保证单例类的惟一性

例如：

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 Test04Old {
    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();
            // 答案显然是false
            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);
}

答案很显然是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-一、对敏感字段加密

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

解决：在序列化过程当中，虚拟机会试图调用对象类里的 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 进行解密，只有拥有密钥的客户端，才能够正确的解析出密码，确保了数据的安全。执行上述代码后控制台输出以下图所示。

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

4-一、对敏感字段加密案例使用 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 +
                '}';
    }
}

执行结果如图所示：

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

五、序列化存储规则

5-一、存储两次相同对象

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 才对，可是最后结果输出如图下图所示。

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

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

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 Test08 {
    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();
            account.setPassword("456789");
            oos.writeObject(account);

            //从文件依次读出两个对象
            Account account1 = (Account) ois.readObject();
            Account account2 = (Account) ois.readObject();

            System.out.println(account1.getPassword());
            System.out.println(account2.getPassword());
        } 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;
    }
}

执行结果以下图：

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

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程