为什么阿里巴巴要求程序员谨慎修改serialVersionUID字段的值

 序列化是一种对象持久化的手段。普遍应用在网络传输、RMI等场景中。类通过实现java.io.Serializable 接口以启用其序列化功能。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站设计、网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的永平网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

在我的博客中，其实已经有多篇文章介绍过序列化了，对序列化的基础知识不够了解的朋友可以参考以下几篇文章：

Java对象的序列化与反序列化

深入分析Java的序列化与反序列化

单例与序列化的那些事儿

在这几篇文章中，我分别介绍过了序列化涉及到的类和接口、如何自定义序列化策略、transient关键字和序列化的关系等，还通过学习ArrayList对序列化的实现源码深入学习了序列化。并且还拓展分析了一下序列化对单例的影响等。

但是，还有一个知识点并未展开介绍，那就是关于serialVersionUID 。这个字段到底有什么用?如果不设置会怎么样?为什么《阿里巴巴Java开发手册》中有以下规定：

背景知识

在展开本文的介绍之前，先来简单介绍一些和序列化有关的知识，内容均来自文章开头的三个文章链接中。

Serializable 和 Externalizable

Java类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法进行序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。

如果读者看过Serializable的源码，就会发现，他只是一个空的接口，里面什么东西都没有。Serializable接口没有方法或字段，仅用于标识可序列化的语义。但是，如果一个类没有实现这个接口，想要被序列化的话，就会抛出java.io.NotSerializableException异常。

它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢?

原因是在执行序列化的过程中，会执行到以下代码：

 
 
 
 
    
  
  
  
  
  1. if (obj instanceof String) {
    2. 
  
  
  
  
  2.    writeString((String) obj, unshared);
    3. 
  
  
  
  
  3. } else if (cl.isArray()) {
    4. 
  
  
  
  
  4.    writeArray(obj, desc, unshared);
    5. 
  
  
  
  
  5. } else if (obj instanceof Enum) {
    6. 
  
  
  
  
  6.    writeEnum((Enum) obj, desc, unshared);
    7. 
  
  
  
  
  7. } else if (obj instanceof Serializable) {
    8. 
  
  
  
  
  8.    writeOrdinaryObject(obj, desc, unshared);
    9. 
  
  
  
  
  9. } else {
    10. 
  
  
  
  
  10.    if (extendedDebugInfo) {
    11. 
  
  
  
  
  11.        throw new NotSerializableException(
    12. 
  
  
  
  
  12.            cl.getName() + "\n" + debugInfoStack.toString());
    13. 
  
  
  
  
  13.    } else {
    14. 
  
  
  
  
  14.        throw new NotSerializableException(cl.getName());
    15. 
  
  
  
  
  15.    }
    16. 
  
  
  
  
  16. }
    17.

在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果都不是则直接抛出NotSerializableException。

Java中还提供了Externalizable接口，也可以实现它来提供序列化能力。

Externalizable继承自Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()。

当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法。否则所有变量的值都会变成默认值。

transient

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

自定义序列化策略

在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。

如果没有这样的方法，则默认调用是 ObjectOutputStream 的defaultWriteObject 方法以及 ObjectInputStream 的defaultReadObject 方法。

用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。

所以，对于一些特殊字段需要定义序列化的策略的时候，可以考虑使用transient修饰，并自己重写writeObject 和 readObject 方法，如java.util.ArrayList中就有这样的实现。

以上，就是一些读者需要掌握和和序列化有关的知识。

我们随便找几个Java中实现了序列化接口的类，如String、Integer等，我们可以发现一个细节，那就是这些类除了实现了Serializable外，还定义了一个serialVersionUID

那么，到底什么是serialVersionUID呢?为什么要设置这样一个字段呢?

什么是serialVersionUID

序列化是将对象的状态信息转换为可存储或传输的形式的过程。我们都知道，Java对象是保存在JVM的堆内存中的，也就是说，如果JVM堆不存在了，那么对象也就跟着消失了。

而序列化提供了一种方案，可以让你在即使JVM停机的情况下也能把对象保存下来的方案。就像我们平时用的U盘一样。把Java对象序列化成可存储或传输的形式(如二进制流)，比如保存在文件中。这样，当再次需要这个对象的时候，从文件中读取出二进制流，再从二进制流中反序列化出对象。

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致，这个所谓的序列化ID，就是我们在代码中定义的serialVersionUID。

如果serialVersionUID变了会怎样

我们举个例子吧，看看如果serialVersionUID被修改了会发生什么?

 
 
 
 
    
  
  
  
  
  1. public class SerializableDemo1 {
    2. 
  
  
  
  
  2.    public static void main(String[] args) {
    3. 
  
  
  
  
  3.        //Initializes The Object
    4. 
  
  
  
  
  4.        User1 user = new User1();
    5. 
  
  
  
  
  5.        user.setName("hollis");
    6. 
  
  
  
  
  6.        //Write Obj to File
    7. 
  
  
  
  
  7.        ObjectOutputStream oos = null;
    8. 
  
  
  
  
  8.        try {
    9. 
  
  
  
  
  9.            oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
    10. 
  
  
  
  
  10.            oos.writeObject(user);
    11. 
  
  
  
  
  11.        } catch (IOException e) {
    12. 
  
  
  
  
  12.            e.printStackTrace();
    13. 
  
  
  
  
  13.        } finally {
    14. 
  
  
  
  
  14.            IOUtils.closeQuietly(oos);
    15. 
  
  
  
  
  15.        }
    16. 
  
  
  
  
  16.    }
    17. 
  
  
  
  
  17. }
    18. 
  
  
  
  
  18. 
  
  
  
  
  19. class User1 implements Serializable {
    20. 
  
  
  
  
  20.    private static final long serialVersionUID = 1L;
    21. 
  
  
  
  
  21.    private String name;
    22. 
  
  
  
  
  22.    public String getName() {
    23. 
  
  
  
  
  23.        return name;
    24. 
  
  
  
  
  24.    }
    25. 
  
  
  
  
  25.    public void setName(String name) {
    26. 
  
  
  
  
  26.        this.name = name;
    27. 
  
  
  
  
  27.    }
    28. 
  
  
  
  
  28. }
    29.

我们先执行以上代码，把一个User1对象写入到文件中。然后我们修改一下User1类，把serialVersionUID的值改为2L。

 
 
 
 
    
  
  
  
  
  1. class User1 implements Serializable {
    2. 
  
  
  
  
  2.    private static final long serialVersionUID = 2L;
    3. 
  
  
  
  
  3.    private String name;
    4. 
  
  
  
  
  4.    public String getName() {
    5. 
  
  
  
  
  5.        return name;
    6. 
  
  
  
  
  6.    }
    7. 
  
  
  
  
  7.    public void setName(String name) {
    8. 
  
  
  
  
  8.        this.name = name;
    9. 
  
  
  
  
  9.    }
    10. 
  
  
  
  
  10. }
    11.

然后执行以下代码，把文件中的对象反序列化出来：

 
 
 
 
    
  
  
  
  
  1. public class SerializableDemo2 {
    2. 
  
  
  
  
  2.    public static void main(String[] args) {
    3. 
  
  
  
  
  3.        //Read Obj from File
    4. 
  
  
  
  
  4.        File file = new File("tempFile");
    5. 
  
  
  
  
  5.        ObjectInputStream ois = null;
    6. 
  
  
  
  
  6.        try {
    7. 
  
  
  
  
  7.            ois = new ObjectInputStream(new FileInputStream(file));
    8. 
  
  
  
  
  8.            User1 newUser = (User1) ois.readObject();
    9. 
  
  
  
  
  9.            System.out.println(newUser);
    10. 
  
  
  
  
  10.        } catch (IOException e) {
    11. 
  
  
  
  
  11.            e.printStackTrace();
    12. 
  
  
  
  
  12.        } catch (ClassNotFoundException e) {
    13. 
  
  
  
  
  13.            e.printStackTrace();
    14. 
  
  
  
  
  14.        } finally {
    15. 
  
  
  
  
  15.            IOUtils.closeQuietly(ois);
    16. 
  
  
  
  
  16.            try {
    17. 
  
  
  
  
  17.                FileUtils.forceDelete(file);
    18. 
  
  
  
  
  18.            } catch (IOException e) {
    19. 
  
  
  
  
  19.                e.printStackTrace();
    20. 
  
  
  
  
  20.            }
    21. 
  
  
  
  
  21.        }
    22. 
  
  
  
  
  22.    }
    23. 
  
  
  
  
  23. }
    24.

执行结果如下：

 
 
 
 
    
  
  
  
  
  1. java.io.InvalidClassException: com.hollis.User1; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
    2.

可以发现，以上代码抛出了一个java.io.InvalidClassException，并且指出serialVersionUID不一致。

这是因为，在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

这也是《阿里巴巴Java开发手册》中规定，在兼容性升级中，在修改类的时候，不要修改serialVersionUID的原因。除非是完全不兼容的两个版本。所以，serialVersionUID其实是验证版本一致性的。

如果读者感兴趣，可以把各个版本的JDK代码都拿出来看一下，那些向下兼容的类的serialVersionUID是没有变化过的。比如String类的serialVersionUID一直都是-6849794470754667710L。

但是，作者认为，这个规范其实还可以再严格一些，那就是规定：

如果一个类实现了Serializable接口，就必须手动添加一个private static final long serialVersionUID变量，并且设置初始值。

为什么要明确定一个serialVersionUID

如果我们没有在类中明确的定义一个serialVersionUID的话，看看会发生什么。

尝试修改上面的demo代码，先使用以下类定义一个对象，该类中不定义serialVersionUID，将其写入文件。

 
 
 
 
    
  
  
  
  
  1. class User1 implements Serializable {
    2. 
  
  
  
  
  2.     private String name;
    3. 
  
  
  
  
  3.     public String getName() {
    4. 
  
  
  
  
  4.         return name;
    5. 
  
  
  
  
  5.     }
    6. 
  
  
  
  
  6.     public void setName(String name) {
    7. 
  
  
  
  
  7.         this.name = name;
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9.  }
    10.

然后我们修改User1类，向其中增加一个属性。在尝试将其从文件中读取出来，并进行反序列化。

 
 
 
 
    
  
  
  
  
  1. class User1 implements Serializable {
    2. 
  
  
  
  
  2.     private String name;
    3. 
  
  
  
  
  3.     private int age;
    4. 
  
  
  
  
  4.     public String getName() {
    5. 
  
  
  
  
  5.         return name;
    6. 
  
  
  
  
  6.     }
    7. 
  
  
  
  
  7.     public void setName(String name) {
    8. 
  
  
  
  
  8.         this.name = name;
    9. 
  
  
  
  
  9.     }
    10. 
  
  
  
  
  10.     public int getAge() {
    11. 
  
  
  
  
  11.         return age;
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13.     public void setAge(int age) {
    14. 
  
  
  
  
  14.         this.age = age;
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16.  }
    17.

执行结果：

 
 
 
 
    
  
  
  
  
  1. java.io.InvalidClassException: com.hollis.User1; local class incompatible: stream classdesc serialVersionUID = -2986778152837257883, local class serialVersionUID = 7961728318907695402
    2.

同样，抛出了InvalidClassException，并且指出两个serialVersionUID不同，分别是-2986778152837257883和7961728318907695402。

从这里可以看出，系统自己添加了一个serialVersionUID。

所以，一旦类实现了Serializable，就建议明确的定义一个serialVersionUID。不然在修改类的时候，就会发生异常。

serialVersionUID有两种显示的生成方式：

一种是默认的1L，比如：

 
 
 
 
    
  
  
  
  
  1. private static final long serialVersionUID = 1L;
    2.

另外一种是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：

 
 
 
 
    
  
  
  
  
  1. private static final long serialVersionUID = xxxxL;
    2.

后面这种方式，可以借助IDE生成，后面会介绍。

背后原理

知其然，要知其所以然，我们再来看看源码，分析一下为什么serialVersionUID改变的时候会抛异常?在没有明确定义的情况下，默认的serialVersionUID是怎么来的?

为了简化代码量，反序列化的调用链如下：

 
 
 
 
    
  
  
  
  
  1. ObjectInputStream.readObject -> 
    2. 
  
  
  
  
  2. readObject0 -> 
    3. 
  
  
  
  
  3. readOrdinaryObject -> 
    4. 
  
  
  
  
  4. readClassDesc -> 
    5. 
  
  
  
  
  5. readNonProxyDesc -> 
    6. 
  
  
  
  
  6. ObjectStreamClass.initNonProxy
    7.

在initNonProxy中 ，关键代码如下：

在反序列化过程中，对serialVersionUID做了比较，如果发现不相等，则直接抛出异常。

深入看一下getSerialVersionUID方法：

 
 
 
 
    
  
  
  
  
  1. public long getSerialVersionUID() {
    2. 
  
  
  
  
  2.    // REMIND: synchronize instead of relying on volatile?
    3. 
  
  
  
  
  3.    if (suid == null) {
    4. 
  
  
  
  
  4.        suid = AccessController.doPrivileged(
    5. 
  
  
  
  
  5.            new PrivilegedAction() {
    6. 
  
  
  
  
  6.                public Long run() {
    7. 
  
  
  
  
  7.                    return computeDefaultSUID(cl);
    8. 
  
  
  
  
  8.                }
    9. 
  
  
  
  
  9.            }
    10. 
  
  
  
  
  10.        );
    11. 
  
  
  
  
  11.    }
    12. 
  
  
  
  
  12.    return suid.longValue();
    13. 
  
  
  
  
  13. }
    14.

在没有定义serialVersionUID的时候，会调用computeDefaultSUID 方法，生成一个默认的serialVersionUID。

这也就找到了以上两个问题的根源，其实是代码中做了严格的校验，并且在未定义的时候自动生成了一个serialVersionUID。

IDEA提示

为了确保我们不会忘记定义serialVersionUID，可以调节一下Intellij IDEA的配置，在实现Serializable接口后，如果没定义serialVersionUID的话，IDEA(eclipse一样)会进行提示：

并且可以一键生成一个：

当然，这个配置并不是默认生效的，需要手动到IDEA中设置一下：

在图中标号3的地方(Serializable class without serialVersionUID的配置)，打上勾，保存即可。

总结

serialVersionUID是用来验证版本一致性的。所以在做兼容性升级的时候，不要改变类中serialVersionUID的值。

特别说明一下，由于本文标题并不完全能表达本文的全部内容，这里再强调一下：serialVersionUID 既然是验证版本一致性的，在做版本升级的时候(非兼容性升级)，记得要修改这个字段的值哦，这样可以避免序列化混乱。

如果一个类实现了Serializable接口，一定要记得定义serialVersionUID，否则会发生异常。可以在IDE中通过设置，让他帮忙提示，并且可以一键快速生成一个serialVersionUID。

之所以会发生异常，是因为反序列化过程中做了校验，并且如果没有明确定义的话，会根据类名及属性等自动生成一个。

【本文是专栏作者Hollis的原创文章，作者微信公众号Hollis(ID：hollischuang)】

网页名称：为什么阿里巴巴要求程序员谨慎修改serialVersionUID字段的值
转载来源：http://www.shufengxianlan.com/qtweb/news10/227010.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

静态网站知识

行业网站建设

重庆网站营销　　 　德阳电信机房　　 　响应式网站建设　　 　微信开发　　 　衣柜书柜酒柜定制　　 　蓬溪网站建设　　 　东方电机技改服务有限公司　　 　成都二枢电信服务器托管　　 　重庆托管服务器　　 　成都网站建设　　 　成都电商网站建设方案　　 　成都网站建设　　 　贵阳托管服务器　　 　专业网站建设　　 　成都VI设计　　 　成都网站安全运维　　 　马边网站建设　　 　租用服务器　　 　攀枝花网站设计　　 　店面门头广告