zoukankan      html  css  js  c++  java

  • Serializable中的serialVersionUID到底有啥用

    最近在研究跨进程通信的问题，于是又再一次研究了，我们熟悉而又陌生的Serializable接口。


    那么好，做过Java开发的朋友肯定对这个接口不陌生吧，Java中就是通过这个接口，来实现了序列化和反序列化的，那么下面看看使用Serializable接口的小例子。

    [java] view plain copy
     print?
    1. public class User implements Serializable{  
    2.     private String name;  
    3.     private int age;  
    4.     private float height;  
    5.     public String getName() {  
    6.         return name;  
    7.     }  
    8.     public void setName(String name) {  
    9.         this.name = name;  
    10.     }  
    11.     public int getAge() {  
    12.         return age;  
    13.     }  
    14.     public void setAge(int age) {  
    15.         this.age = age;  
    16.     }  
    17.     public float getHeight() {  
    18.         return height;  
    19.     }  
    20.     public void setHeight(float height) {  
    21.         this.height = height;  
    22.     }  
    23.     @Override  
    24.     public String toString() {  
    25.         return "User [name=" + name + ", age=" + age + ", height=" + height + "]";  
    26.     }  
    27.       
    28. }  


    上面是我们常见写法的bean，不过呢，Eclipse就会有这个提示：The serializable class User does not declare a static final serialVersionUID field of type long，意思就是说让你添加一个serialVersionUID的值。

    不过呢，我们就算不添加，那么也是可以正常序列化的。下面贴一下序列化和反序列化的代码。

    [java] view plain copy
     print?
    1. public class Test {  
    2.   
    3.     private static String FILE_PATH = "cache.txt";  
    4.   
    5.     /** 
    6.      * 测试SerialVersionUID和不同是否能发序列化成功 
    7.      *  
    8.      * @param args 
    9.      */  
    10.     public static void main(String[] args) {  
    11.         // 创建一个对象  
    12.         User user = new User();  
    13.         user.setAge(10);  
    14.         user.setName("小可爱");  
    15.         user.setHeight(175.6f);  
    16.         // 开始序列化  
    17.         ObjToFile(user);  
    18.         // 开始反序列化  
    19.         Object o = FileToObj();  
    20.         System.out.println("=====================");  
    21.         System.out.println(o.toString());  
    22.     }  
    23.   
    24.     /** 
    25.      * 序列化 
    26.      */<del>  
    27. </del>    public static void ObjToFile(Serializable s) {  
    28.         ObjectOutputStream _Oos = null;  
    29.         try {  
    30.             _Oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH));  
    31.             _Oos.writeObject(s);  
    32.             _Oos.flush();  
    33.             System.out.println("序列化成功！");  
    34.         } catch (FileNotFoundException e) {  
    35.             e.printStackTrace();  
    36.         } catch (IOException e) {  
    37.             e.printStackTrace();  
    38.         } finally {  
    39.             if (_Oos != null) {  
    40.                 try {  
    41.                     _Oos.close();  
    42.                 } catch (IOException e) {  
    43.                     e.printStackTrace();  
    44.                 }  
    45.             }  
    46.         }  
    47.     }  
    48.   
    49.     /** 
    50.      * 反序列化 
    51.      */  
    52.     public static Serializable FileToObj() {  
    53.         ObjectInputStream _Ois = null;  
    54.         try {  
    55.             _Ois = new ObjectInputStream(new FileInputStream(FILE_PATH));  
    56.             Serializable s = (Serializable) _Ois.readObject();  
    57.             System.out.println("反序列化成功");  
    58.             return s;  
    59.         } catch (FileNotFoundException e) {  
    60.             e.printStackTrace();  
    61.         } catch (IOException e) {  
    62.             e.printStackTrace();  
    63.         } catch (ClassNotFoundException e) {  
    64.             e.printStackTrace();  
    65.         } finally {  
    66.             if (_Ois != null) {  
    67.                 try {  
    68.                     _Ois.close();  
    69.                 } catch (IOException e) {  
    70.                     e.printStackTrace();  
    71.                 }  
    72.             }  
    73.         }  
    74.         return null;  
    75.     }  
    76.   
    77. }  


    先说第一种情况：

    其实，如果你不添加serialVersionUID，那么Eclipse在会根据这个类的结构（成员变量，成员变量的个数等），生成一个hash值，然后将这个值作为serialVersionUID。

    告诉大家实验步骤：

    1、序列化User对象的时候，不要添加serialVersionUID。

    2、然后给User对象添加serialVersionUID = 2L,可以随便是个long值。

    3、开始对新添加的User对象，进行反序列化。

    接着大家就可以看到控制台打印的报错了。

    我这边的报错是这样的：

    java.io.InvalidClassException: com.peng.test.User; local class incompatible: stream classdesc serialVersionUID = -2110639933710420778, local class serialVersionUID = 2

    看到上面的这个serialVersionUID = -2110639933710420778了吗,我们序列化的时候，不是没有添加serialVersionUID的值吗。
    当然了，这种方式只能说明serialVersionUID这个值会自己生成，那么就这样确定是Eclipse生成的，仿佛证据不是很确凿，不过呢，还有一种方法，来证明一下，那就是不使用Eclipse，直接使用文本编辑器，如果根本不能序列化，那么就是Eclipse的问题了。

    第二种情况：
    如果你没有添加serialVersionUID，进行了序列化，而你在反序列化的时候，修改了User对象的结构（添加或删除成员变量，修改成员变量的命名），那么这个时候，就会出现上面的报错。

    第三种情况：

    如果你添加了serialVersionUID，进行了序列化，而你在反序列化的时候，修改了User对象的结构（添加或删除成员变量，修改成员变量的命名），那么就不见的报错了，不过反序列化，它只能恢复部分数据，或者恢复不了数据。

    总结一下：
    序列化的时候，系统会把序列化的类的serialVersionUID写入到序列化文件中（有可能其他地方）,当去反序列化的时候，系统会去检测文件中的serialVersionUID，如果类中的值和文件的值一致，那么就可以反序列化成功，反之失败。
  • 相关阅读:
    ASP.net中页面事件的先后顺序
    我回来了
    ASP.NET中添加引用不能显示
    VS2008中MVC无法打开项目文件，此安装不支持该项目类型
    windows2003 IIS错误
    C#中使用TimeSpan计算两个时间的差值
    javascript做在翻译
    GridView导出EXCEL
    用资源管理器限制大数据量查询
    linux单机配置DG过程记录
  • 原文地址：https://www.cnblogs.com/jpfss/p/8276308.html
Copyright © 2011-2022 走看看