java序列化反序列化uid

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

     当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class自动生成一个serialVersionUID作序列化版本比较用，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID 。

如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。

    以上两段话摘自http://blog.sina.com.cn/s/blog_3e9d2b3501011uy8.html，以前只知道序列化ID的此作用，但实际并未碰到过。昨天有幸一见，现把场景回忆如下：

    环境：

    1）分布式即多台resin服务器；

    2）序列化的java类没有显示定义serialVersionUID；

    3）使用了redis作为缓存（序列化后的对象存入redis缓存中）；

    在使用过程，报序列化时候版本不兼容，即serialVersionUID不同异常。由于不显示定义serialVersionUID，在分布式环境，相同类的class在不同resin在的class的serialVersionUID不同，反序列化就容易报此异常。

    所以，在使用序列化过程中，最好显示定义序列号。

============================

============================

什么是序列化和反序列化

    Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。

什么情况下需要序列化 

• 当你想把的内存中的对象保存到一个文件中或者数据库中时候(数据持久化)；
• 利用序列化实现远程通信，即在网络上传送对象的字节序列；

如何实现序列化

    将需要序列化的类实现Serializable接口就可以了，Serializable接口中没有任何方法，可以理解为一个标记，即表明这个类可以序列化.

序列化和反序列化例子

    如果我们想要序列化一个对象，首先要创建某些OutputStream(如FileOutputStream、ByteArrayOutputStream等)，然后将这些OutputStream封装在一个ObjectOutputStream中。这时候，只需要调用writeObject()方法就可以将对象序列化，并将其发送给OutputStream（记住：对象的序列化是基于字节的，不能使用Reader和Writer等基于字符的层次结构）。而反序列的过程（即将一个序列还原成为一个对象），需要将一个InputStream(如FileInputstream、ByteArrayInputStream等)封装在ObjectInputStream内，然后调用readObject()即可。

    举例如下:

[java]  view plain copy

1. package com.serialize;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.Serializable;  
10.   
11. public class Serialize implements Serializable{  
12.   
13.     private static final long serialVersionUID = -5211389707739541364L;  
14.     public int num = 1390;  
15.   
16.     public void serialized()  
17.     {  
18.         try {  
19.             FileOutputStream fos = new FileOutputStream("serialize.obj");  
20.             ObjectOutputStream oos = new ObjectOutputStream(fos);  
21.             Serialize serialize = new Serialize();  
22.             oos.writeObject(serialize);  
23.             oos.flush();  
24.             oos.close();//只是为了方便简洁的做个例子，真实编程要放到finally下，懂的人你懂的。  
25.             fos.close();  
26.             System.out.println("序列化结束");  
27.         } catch (FileNotFoundException e) {  
28.             e.printStackTrace();  
29.         } catch (IOException e) {  
30.             e.printStackTrace();  
31.         }  
32.     }  
33.   
34.     public void deserialized()  
35.     {  
36.         Serialize serialize = null;  
37.         try  
38.         {  
39.             FileInputStream fis = new FileInputStream("serialize.obj");  
40.             ObjectInputStream ois = new ObjectInputStream(fis);  
41.   
42.             serialize = (Serialize) ois.readObject();  
43.             ois.close();  
44.             fis.close();  
45.             System.out.println("反序列化结束");  
46.         }  
47.         catch (ClassNotFoundException | IOException e)  
48.         {  
49.             e.printStackTrace();  
50.         }  
51.         System.out.println(serialize.num);  
52.     }  
53.   
54.     public static void main(String[] args)   
55.     {  
56.         Serialize serialize = new Serialize();  
57.         serialize.serialized();  
58.         serialize.deserialized();  
59.     }  
60. }  

运行结果：

[plain]  view plain copy

1. 序列化结束  
2. 反序列化结束  
3. 1390  

序列化的数据含有那些信息

    这里举个例子将上面例子中的serialize.obj的信息读取出来：

[java]  view plain copy

1. package com.serialize;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.IOException;  
7. import java.io.InputStream;  
8.   
9. public class ReadSerialize {  
10.   
11.     public static void main(String[] args) {  
12.         try {  
13.             File file = new File("serialize.obj");  
14.             InputStream in = new FileInputStream(file);  
15.             byte buff[] = new byte[1024];  
16.             int len = 0;  
17.             while((len = in.read(buff)) !=-1)  
18.             {  
19.                 for(int i=0;i<len;i++)  
20.                 {  
21.                     System.out.printf("%02X ",buff[i]);  
22.                 }  
23.                 System.out.println();  
24.             }  
25.         } catch (FileNotFoundException e) {  
26.             e.printStackTrace();  
27.         } catch (IOException e) {  
28.             e.printStackTrace();  
29.         }  
30.     }  
31. }  

运行结果：

[plain]  view plain copy

1. AC ED 00 05 73   
2. 72 00 17 63 6F 6D 2E 73 65 72 69 61 6C 69 7A 65 2E 53 65 72 69 61 6C 69 7A 65 B7 AD 6C AC 04 0E D0 8C 02 00 01   
3. 49 00 03 6E 75 6D   
4. 78 70  
5. 00 00 05 6E  

解析：
第一部分是序列化文件头
AC ED：STREAM_MAGIC声明使用了序列化协议
00 05：STREAM_VERSION序列化协议版本
73：TC_OBJECT声明这是一个新的对象
第二部分是序列化类的描述
72：TC_CLASSDESC声明这里开始一个新class
00 17：class名字的长度是23字节
63 6F 6D 2E 73 65 72 69 61 6C 69 7A 65 2E 53 65 72 69 61 6C 69 7A 65:类名（ASCII码：com.serialize.Serialize）
B7 AD 6C AC 04 0E D0 8C： SerialVersionUID
02：标记号，改值声明改对象支持序列化
00 01：该类所包含的域的个数为1
第三部分是对象中各个属性项的描述
49：域类型，代表I,表示Int类型（又如：44，查ASCII码表为D，代表Double类型）
00 03：域名字的长度，为3
6E 75 6D: num属性的名称
第四部分输出该对象父类信息描述，这里没有父类，如果有，则数据格式与第二部分一样
78：TC_ENDBLOCKDATA，对象块接收标志
70：TC_NULL，说明没有其他超类的标志
第五部分输出对象的属性的实际值，如果属性项是一个对象，那么这里还将序列化这个对象，规则和第2部分一样。
00 00 05 6E：1390的值
序列化前和序列化后的对象的关系
    序列化时深复制，反序列化还原后的对象地址与原来的不同。
    如下例子：

[java]  view plain copy

1. package com.serialize;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.Serializable;  
10.   
11. public class Serialize implements Serializable{  
12.   
13.     private static final long serialVersionUID = -5211389707739541364L;  
14.     public int num = 1390;  
15.   
16.     public void checkIsSame()  
17.     {  
18.         Serialize serialize1 = new Serialize();  
19.         try  
20.         {  
21.             FileOutputStream fos = new FileOutputStream("serialize.obj");  
22.             ObjectOutputStream oos = new ObjectOutputStream(fos);  
23.             oos.writeObject(serialize1);  
24.             oos.flush();  
25.             oos.close();//只是为了方便简洁的做个例子，真实编程要放到finally下，懂的人你懂的。  
26.             fos.close();  
27.             System.out.println("序列化结束");  
28.         }  
29.         catch (IOException e)  
30.         {  
31.             e.printStackTrace();  
32.         }  
33.         Serialize serialize2 = null;  
34.         try  
35.         {  
36.             FileInputStream fis = new FileInputStream("serialize.obj");  
37.             ObjectInputStream ois = new ObjectInputStream(fis);  
38.   
39.             serialize2 = (Serialize) ois.readObject();  
40.             ois.close();  
41.             fis.close();  
42.             System.out.println("反序列化结束");  
43.         }  
44.         catch (ClassNotFoundException | IOException e)  
45.         {  
46.             e.printStackTrace();  
47.         }  
48.         System.out.println("序列化和反序列化的对象相同否？"+(serialize1==serialize2));  
49.     }  
50.   
51.     public static void main(String[] args)   
52.     {  
53.         Serialize serialize = new Serialize();  
54.         serialize.checkIsSame();  
55.     }  
56. }  

运行结果：

[plain]  view plain copy

1. 序列化结束  
2. 反序列化结束  
3. 序列化和反序列化的对象相同否？false  

    序列化前后对象的地址不同了，但是内容是一样的，而且对象中包含的引用也相同。换句话说，通过序列化操作,我们可以实现对任何可Serializable对象的”深度复制（deep copy）"——这意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。对于同一流的对象，他们的地址是相同，说明他们是同一个对象，但是与其他流的对象地址却不相同。也就说，只要将对象序列化到单一流中，就可以恢复出与我们写出时一样的对象网，而且只要在同一流中，对象都是同一个。

破坏单例模式

    序列化和反序列化可能会破坏单例。上面的例子就是个很好的证明，为了更形象，在举一个单例模式的序列化的例子，有关单例模式不了解的话，可以参考博文http://blog.csdn.net/u013256816/article/details/50427061

[java]  view plain copy

1. package com.serialize;  
2.   
3. import java.io.Serializable;  
4.   
5. public class SerSingleton implements Serializable  
6. {  
7.     private static final long serialVersionUID = 1L;  
8.   
9.     String name;  
10.   
11.     private SerSingleton()  
12.     {  
13.         System.out.println("Singleton is create");  
14.         name="SerSingleton";  
15.     }  
16.   
17.     private static SerSingleton instance = new SerSingleton();  
18.   
19.     public static SerSingleton getInstance()  
20.     {  
21.         return instance;  
22.     }  
23.   
24.     public static void createString()  
25.     {  
26.         System.out.println("createString in Singleton");  
27.     }  
28. }  
29.   
30.     @Test  
31.     public void test() throws IOException, ClassNotFoundException  
32.     {  
33.         SerSingleton s1= null;  
34.         SerSingleton s = SerSingleton.getInstance();  
35.   
36.         FileOutputStream fos = new FileOutputStream("SerSingleton.obj");  
37.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
38.         oos.writeObject(s);  
39.         oos.flush();  
40.         oos.close();  
41.   
42.         FileInputStream fis = new FileInputStream("SerSingleton.obj");  
43.         ObjectInputStream ois = new ObjectInputStream(fis);  
44.         s1 = (SerSingleton)ois.readObject();  
45.        System.out.println(s==s1);  
46.     }  

运行结果：

[plain]  view plain copy

1. Singleton is create  
2. false  

    说明测试代码中的s和s1指向了不同的实例，在反序列化后，生成多个对象实例。
    接下来我们稍微修改一下SerSingleton类，如下所示：

[java]  view plain copy

1. package com.serialize;  
2.   
3. import java.io.Serializable;  
4.   
5. public class SerSingleton implements Serializable  
6. {  
7.     private static final long serialVersionUID = 1L;  
8.   
9.     String name;  
10.   
11.     private SerSingleton()  
12.     {  
13.         System.out.println("Singleton is create");  
14.         name="SerSingleton";  
15.     }  
16.   
17.     private static SerSingleton instance = new SerSingleton();  
18.   
19.     public static SerSingleton getInstance()  
20.     {  
21.         return instance;  
22.     }  
23.   
24.     public static void createString()  
25.     {  
26.         System.out.println("createString in Singleton");  
27.     }  
28.   
29.     private Object readResolve()  
30.     {  
31.         return instance;  
32.     }  
33. }  

    注意程序中加粗的部分，然后运行测试代码，结果如下：

[plain]  view plain copy

1. Singleton is create  
2. true  

    至于为什么，可以查看ObjectIputStream.class的源码，当中有这样一段话（英文就不翻译了，大家应该能看懂）：

    Deserializing an object via readUnshared invalidates the stream handle associated with the returned object. Note that this in itself does not always guarantee that the reference returned by readUnshared is unique; the deserialized object may define a readResolve method which returns an object visible to other parties, or readUnshared may return a Class object or enum constant obtainable elsewhere in the stream or through external means. If the deserialized object defines a readResolve method and the invocation of that method returns an array, then readUnshared returns a shallow clone of that array; this guarantees that the returned
array object is unique and cannot be obtained a second time from an invocation of readObject or readUnshared on the ObjectInputStream, even if the underlying data stream has been manipulated.

    一般来说，对单例进行序列化和反序列化的场景并不多见，但如果存在，就要多加注意。

序列化ID

    序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。这也可能是造成序列化和反序列化失败的原因，因为不同的序列化id之间不能进行序列化和反序列化。

静态变量能否序列化

    序列化会忽略静态变量，即序列化不保存静态变量的状态。静态成员属于类级别的，所以不能序列化。即 序列化的是对象的状态不是类的状态。这里的不能序列化的意思，是序列化信息中不包含这个静态成员域。transient后的变量也不能序列化。

    transient使用小结

• 一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
• transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
• 被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

总结

• 当父类继承Serializable接口时，所有子类都可以被序列化。
• 子类实现了Serializable接口，父类没有，父类中的属性不能被序列化（不报错，数据不会丢失），但是在子类中的属性仍能正确序列化
• 如果序列化的属性是对象，则这个对象也必须实现Serializable接口，否则会报错。
• 在反序列化时，如果对象的属性有修改或删减，则修改的部分属性会丢失，但不会报错。
• 在反序列化时，如果serialVersionUID被序列化，则反序列化时会失败
• 当一个对象的实例变量引用其他对象，序列化改对象时，也把引用对象进行序列化
• static,transient后的变量不能被序列化