Java 记录序列化和对规范构造函数的重复调用

问题描述

在this post about serializable records中声明

反序列化通过调用记录类的规范构造函数来创建一个新的记录对象，将从流中反序列化的值作为参数传递给规范构造函数。这是安全的，因为这意味着记录类可以在将值分配给字段之前对其进行验证，就像普通 Java 程序通过 new 创建记录对象一样。 “不可能”的对象是不可能的。

这与仅用于验证的构造函数争论。然而，当构造函数操作参数时，这会导致相当奇怪的行为。考虑这个非常人为的简单示例：

以下记录在保存前对 a 进行操作：

import java.io.Serializable;

public record TRecord (int a) implements Serializable {
    public TRecord {
        a = a-1;
    }
}

下面的程序只是第一次保存序列化的记录并在随后的时间加载它：

import java.io.*;

public class TestRecords {

    public static void main(String args[]) {
        TRecord a1 = null;

        try {
            FileInputStream fileIn = new FileInputStream("tmp");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            a1 = (TRecord) in.readobject();
            in.close();
            fileIn.close();
        } catch (IOException | ClassNotFoundException i) {
            // ignore for Now
        }
        if (a1 == null) {
            try {
                a1 = new TRecord(5);
                FileOutputStream fileOut = new FileOutputStream("tmp");
                ObjectOutputStream out = new ObjectOutputStream(fileOut);
                out.writeObject(a1);
                out.close();
                fileOut.close();
                System.out.printf("Serialized data is saved in /tmp/employee.ser");
            } catch (IOException i) {
                i.printstacktrace();
            }
        }

        System.out.println(a1);
    }
}

第一次运行的输出是 TRecord[a=4]，后续运行的输出是 TRecord[a=3]，所以我从反序列化中得到的状态与我在那里输入的不同。改用如下类似的类，每次都会得到相同的结果 TClass[a=4]。

import java.io.Serializable;

public class TClass implements Serializable {
    private int a;

    public TClass(final int a) {
        this.a = a-1;
    }

    public int getA() {return a;}

    public String toString() {
        return "Class[" + a + "]";
    }
}

所以我的问题是：是否有任何规则禁止/不鼓励将构造函数用于验证以外的任何内容（例如，我正在考虑在存储输入之前对密码进行哈希处理）？或者有没有其他方法可以反序列化一个对象，从而恢复初始状态？

解决方法

如果您查看 records 的文档，它会说明以下内容：

对于所有记录类，以下不变量必须保持：如果记录 R 的组件是 c1,c2,... cn,那么如果复制了一个记录实例 如下：

 R copy = new R(r.c1(),r.c2(),...,r.cn());  

那么一定是 r.equals(copy) 的情况。

然而，这不是你的记录类的情况：

jshell> TRecord r1 = new TRecord(42);
r1 ==> TRecord[a=41]

jshell> TRecord copy = new TRecord(r1.a());
copy ==> TRecord[a=40]

jshell> r1.equals(copy)
$4 ==> false

换句话说，你的记录类型违反了这个不变量，这也是你看到不一致反序列化的原因。