serialVersionUID 对于外部化类真的有意义吗？

Question

我已经阅读了一些关于 Java 如何控制对 Serializable 对象的访问的问题和讨论。我的问题是关于 Externalizable 对象以及为什么 serialVersionUID 应该 影响它。我预计答案将是“因为 Externalizable 接口扩展了 Serializable 接口”，因此该字段是必需的。我承认有些烦人的回答是“为什么 Externalizable 扩展 Serializable？”有两个原因。

第一个原因很简单，实现外部化需要重写 readExternal 和 writeExternal 以将数据传入和传出类实例。

第二个有点复杂，但情况如下：

我的新 Foo 类当前包含两个 String 字段，但我希望它会随着我的函数的增长而增长，因为用户更改了一些要求。如果我将 Foo 声明为可序列化，我可以毫无问题地将对象写入文件，直到我需要更新类以添加另一个字段。现在我不能在一个程序中拥有两个版本的 Foo 对象，因此现有 Foo 对象的任何文件都是垃圾，如果不编写一个函数就无法处理读取当前的 Foo 文件并将其写为文本，然后另一个函数来读取文本，对新的 Foo 字段赋值并将其写为序列化表单的更新版本。

所以我的想法是我应该将 Foo 声明为 Externalizable，添加一个内部版本字段，这是通过 writeExternal 函数写入的第一个字段，因此 readExternal 函数首先读取该字段，其余部分可以根据该值进行控制。

将两个版本并排比较：

enter code
    Original version                                          Updated version

 1  public class Foo implements Externalizable {              public class Foo implements Externalizable {
 2                        
 3    static final private long serialVersionUID=????;          static final private long serialVersionUID=????;
 4    static final private long VER00=0;                        static final private long VER00=0;
 5                                                     *****    static final private long VER01=1;
 6
 7    private int fooVer=0;                                     private int fooVer=1;
 8    public String dsn="", lst="";                    *****    public String dsn="", lst="", ext="";
 9    public String getDsn() {return dsn;}                      public String getDsn() {return dsn;}
10    public String getLst() {return lst;}                      public String getLst() {return lst;}
11                                                     *****    public String getExt() {return ext;}
12    public void putDsn(String s) {dsn=s;}                     public void putDsn(String s) {dsn=s;}
13    public void putLst(String s) {lst=s;}                     public void putLst(String s) {lst=s;}
14                                                     *****    public void putExt(String s) {ext=s;}
15                        
16    public Foo() {super();}                                   public Foo() {super();}
17                        
18    @Override                                                @Override
19    public void readExternal(ObjectInput in)                 public void readExternal(ObjectInput in)
20      throws IOException, ClassNotFoundException {             throws IOException, ClassNotFoundException {
21      this.fooVer=in.readLong();                               this.fooVer=in.readLong();
22                                                     *****     if (this.fooVer==VER01) {
23                                                     *****       this.dsn=(String) in.readObject();
24                                                     *****       this.lst=(String) in.readObject();
25                                                     *****       this.ext=(String) in.readObject();
26                                                     *****       return;
27                                                     *****     }
28      if (this.fooVer==VER00) {                                if (this.fooVer==VER00) {
29        this.dsn=(String) in.readObject();                       this.dsn=(String) in.readObject();
30        this.lst=(String) in.readObject();                       this.lst=(String) in.readObject();
31                                                     *****       this.ext="no ext available";
32        return;                                                  return;
33      }                                                        }
34      throw new ClassNotFoundException                         throw new ClassNotFoundException
35        ("unsupported fooVer "+this.fooVer);                     ("unsupported fooVer "+this.fooVer);
36    }                                                        }
37                        
38    @Override                                                @Override
39    public void writeExternal(ObjectOutput out)              public void writeExternal(ObjectOutput out)
40      throws IOException {                                     throws IOException {
41      fooVer=VER00;                                  *****     fooVer=VER01;
42      out.writeLong(fooVer);                                   out.writeLong(fooVer);
43      out.writeObject(dsn);                                    out.writeObject(dsn);
44      out.writeObject(lst);                                    out.writeObject(lst);
45                                                     *****     out.writeObject(ext);
46    }                                                        }
47  }                                                        }

here

由于 Foo 控制外部化，我应该能够使值不同，例如 0 和 1，并且仍然正确处理记录，但是如果我使用旧值写入并在第一次读取时使用新值读取，我得到一个 InvalidClassException ，其中消息是： “本地类不兼容：流 classdesc serialVersionUID = 0，本地类 serialVersionUID = 1”。

因此，据我所知，无论我多么小心，我都必须简单地为 serialVersionUID 选择一个值，并且永远不要更改它，除非我想丢失所有早期数据。因此，我基本上做了很多额外的工作来防止序列化使用 serialVersionUID 来做它打算做的事情。 ：/

我错过了什么吗？

Answer 1

我必须简单地为 serialVersionUID 选择一个值，并且永远不要更改它，除非我想丢失所有早期数据

这是正确的，无论您实现Ssrializable 还是Externalizable，它都适用。