serialVersionUID的作用

来源：互联网发布：javascript的continue 编辑：程序博客网时间：2024/06/05 09:52

Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

Eclipse中The serializable class XXXXXX does not declare a static final serialVersionUID field of type long出现这样的警告处理办法。

当采用程序的Add default Serial version ID修复时，Eclipse会加上：private static final long serialVersionUID = 1L;

当采用程序的Add generated Serial version ID修复时，Eclipse会加上：private static final long serialVersionUID = xxxxL;

其实这个问题出现的具体原因是和序列化中的这个serialVersionUID有关。

serialVersionUID 用来表明类的不同版本间的兼容性。有两种生成方式：

一个是默认的1L，比如：private static final long serialVersionUID = 1L;（对应修复方法1）

一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
private static final long serialVersionUID = xxxxL;（对应修复方法2）

在JDK中，可以利用JDK的bin目录下的serialver.exe工具产生这个serialVersionUID 的值，对于Test.class，执行命令：
serialver Test 这时JVM（java虚拟机）会生成一个哈希字段。

对比一下这个哈希字段的值与方法2中生成的字段值是一样的，可见，在CMD中使用serialver指令就是根据类名、接口名、成员方法及属性等来生成哈希字段的。

下面来讨论java类中为什么需要重载 serialVersionUID 属性。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

　　把Java对象转换为字节序列的过程称为对象的序列化。

　　把字节序列恢复为Java对象的过程称为对象的反序列化。

　　对象的序列化主要有两种用途：

　　1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

　　2）在网络上传送对象的字节序列。

当实现java.io.Serializable接口的类没有显式地定义一个serialVersionUID变量时候，Java序列化机制会根据编译的Class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果Class文件(类名，方法明等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID也不会变化的。

当一个类实现了Serializable接口，如果没有显示的定义serialVersionUID，Eclipse会提供相应的提醒。面对这种情况，我们只需要在Eclipse中点击类中warning图标一下，Eclipse就会自动给定两种生成的方式。如果不想定义，在Eclipse的设置中也可以把它关掉的，设置如下：
Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems
将Serializable class without serialVersionUID的warning改成ignore即可。

下面用代码说明一下serialVersionUID在应用中常见的几种情况。

（1）序列化实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.Serializable;
publicclassPersonimplementsSerializable
{
    privatestaticfinallongserialVersionUID=1234567890L;
    publicintid;
    publicStringname;
 
    publicPerson(intid,Stringname)
    {
        this.id=id;
        this.name=name;
    }
 
    publicStringtoString()
    {
        return"Person: "+id+" "+name;
    }
}

（2）序列化功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectOutputStream;
 
publicclassSerialTest
{
 
    publicstaticvoidmain(String[]args)throwsIOException
    {
        Personperson=newPerson(1234,"wang");
        System.out.println("Person Serial"+person);
        FileOutputStreamfos=newFileOutputStream("Person.txt");
        ObjectOutputStreamoos=newObjectOutputStream(fos);
        oos.writeObject(person);
        oos.flush();
        oos.close();
    }
}

（3）反序列化功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.ObjectInputStream;
publicclassDeserialTest
{
    publicstaticvoidmain(String[]args)throwsIOException,ClassNotFoundException
    {
        Personperson;
 
        FileInputStreamfis=newFileInputStream("Person.txt");
        ObjectInputStreamois=newObjectInputStream(fis);
        person=(Person)ois.readObject();
        ois.close();
        System.out.println("Person Deserial"+person);
    }
 
}

情况一：假设Person类序列化之后，从A端传输到B端，然后在B端进行反序列化。在序列化Person和反序列化Person的时候，A端和B端都需要存在一个相同的类。如果两处的serialVersionUID不一致，会产生什么错误呢?
【答案】可以利用上面的代码做个试验来验证：
先执行测试类SerialTest，生成序列化文件，代表A端序列化后的文件，然后修改serialVersion值，再执行测试类DeserialTest，代表B端使用不同serialVersion的类去反序列化，结果报错:
Exception in thread "main" java.io.InvalidClassException: test.Person; local class incompatible: stream classdesc serialVersionUID = 1234567890, local class serialVersionUID = 123456789
   at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:560)
   at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1580)
   at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1493)
   at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1729)
   at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1326)
   at java.io.ObjectInputStream.readObject(ObjectInputStream.java:348)
   at test.DeserialTest.main(DeserialTest.java:15)

情况二：假设两处serialVersionUID一致，如果A端增加一个字段，然后序列化，而B端不变，然后反序列化，会是什么情况呢?
【答案】新增 public int age; 执行SerialTest，生成序列化文件，代表A端。删除 public int age，反序列化，代表B端，最后的结果为：执行序列化，反序列化正常，但是A端增加的字段丢失(被B端忽略)。

情况三：假设两处serialVersionUID一致，如果B端减少一个字段，A端不变，会是什么情况呢?
【答案】序列化，反序列化正常，B端字段少于A端，A端多的字段值丢失(被B端忽略)。

情况四：假设两处serialVersionUID一致，如果B端增加一个字段，A端不变，会是什么情况呢?
验证过程如下：
先执行SerialTest，然后在实体类Person增加一个字段age，如下所示，再执行测试类DeserialTest.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importjava.io.Serializable;
publicclassPersonimplementsSerializable
{
    privatestaticfinallongserialVersionUID=123456789L;
    publicintid;
    publicStringname;
    publicintage;
 
    publicPerson(intid,Stringname)
    {
        this.id=id;
        this.name=name;
    }
 
    publicStringtoString()
    {
        return"Person: "+id+" "+name;
    }
}

相应的修改测试类DeserialTest，打印出age的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectOutputStream;
 
publicclassSerialTest
{
 
    publicstaticvoidmain(String[]args)throwsIOException
    {
        Personperson=newPerson(1234,"wang");
        System.out.println("Person Serial"+person+" age:"+person.age);
        FileOutputStreamfos=newFileOutputStream("Person.txt");
        ObjectOutputStreamoos=newObjectOutputStream(fos);
        oos.writeObject(person);
        oos.flush();
        oos.close();
    }
}

结果为：
Person Deserial Person: 1234 wang age: 0
说明序列化，反序列化正常，B端新增加的int字段被赋予了默认值0。
最后通过下面的图片，总结一下上面的几种情况。

本文部分来自网络http://swiftlet.net/archives/1268；

阅读全文

0 0