Java序列化接口的作用

转载至：http://www.cnblogs.com/DreamDrive/p/4005966.html

               http://www.cnblogs.com/DreamDrive/p/5412931.html

一个对象有对应的一些属性,把这个对象保存在硬盘上的过程叫做”持久化”.

把堆内存中的对象的生命周期延长,存入硬盘,做持久化操作.当下次再需要这个对象的时候,我们不用new了,直接从硬盘中读取就可以了.(存储到硬盘是一个文件,不需要我们去解析,如果用记事本打开解析会出现乱码,解析要用特定的方式,不用我们管. 我们只需要读取).

把对象存储到硬盘上的一个文件中,这个文件的标准扩展名是(.object).

在很多框架中就会有这种.object结尾的文件,因为很多对象都不创建,创建起来太麻烦,直接读取,而且有些对象的值你不知道,框架封存在.object文件中,直接读取这个文件中的这个值就行了,不需要传这个值.

 1 import java.io.Serializable;
 2 /*
 3  * Serializable:用于给被序列化的类加入ID号。
 4  * 用于判断类和对象是否是同一个版本。 
 5  */
 6 public class Person implements Serializable/*标记接口*/ {
 7     /**
 8      * transient:非静态数据不想被序列化可以使用这个关键字修饰。 
 9      */
10     private static final long serialVersionUID = 9527l; 
11 //    private transient String name;
12     private  String name;
13 //    private static int age;
14     private int age;
15 
16     public Person(String name, int age) {
17         super();
18         this.name = name;
19         this.age = age;
20     }
21     public String getName() {
22         return name;
23     }
24     public void setName(String name) {
25         this.name = name;
26     }
27     public int getAge() {
28         return age;
29     }
30     public void setAge(int age) {
31         this.age = age;
32     }
33 }

 1 public class ObjectStreamDemo {
 2     /**
 3      * @param args
 4      * @throws IOException 
 5      * @throws ClassNotFoundException 
 6      */
 7     public static void main(String[] args) throws IOException, ClassNotFoundException {
 8         //writeObj();
 9         readObj();
10     }
11     public static void readObj() throws IOException, ClassNotFoundException {
12         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));
13         //对象的反序列化。 
14         Person p = (Person)ois.readObject();
15         System.out.println(p.getName()+":"+p.getAge());
16         ois.close();
17     }
18 
19     public static void writeObj() throws IOException, IOException {
20         
21         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));
22         //对象序列化。  被序列化的对象必须实现Serializable接口。 
23         oos.writeObject(new Person("小强",30));
24         oos.close();
25     }
26 }

序列号的作用:举个例子,当你一开始对这个person类进行序列化的时候用的是private类型序列化的,但是你在反序列化之前,把这个private改成了public.这样反序列化读取的时候就会报出异常.

Exception in thread "main" java.io.InvalidClassException: cn.itcast.serializable.Person; local class incompatible: stream classdesc serialVersionUID = 9527, local class serialVersionUID = 7915096815468332737

 

就是关于前后这个Person类的版本号不统一.如果加上设定一个版本号,那么经过上面的修改也是可以反序列化的.

 

@throws ClassNotFoundException

如果只有obj.object 这个文件能不能把其中的对象Person取出来,因为任何对象在堆内存中创建都必须依赖于该对象所属的类文件(class文件),如果仅仅给了obj.object,这个里面有Person对象的字节码,可是取出的时候你内存中并没有Person.class文件,没有,所以取不出来,所以必须要有obj.object文件和Person.class文件.(所以有一个ClassNotFound异常)

 

类 ObjectInputStream

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

这句话的意思就是ObjectInputStream只能读取ObjectOutputStream的.

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。

 

序列化就是按照顺序排列

Serializable就是一个标记,(要想实现序列化必须有这个标记)

对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。(因为静态static的东西在方法区.)

 

使用时候:对某些特点的对象,比如数据库连接对象,存储特定数据的对象 ,这样对象你不想创建他们,想存储起来,让他们的生命周期延长,可以把他们放在硬盘当中.每次系统启动的时候都到.object中读取对象和里面的数据,这个时候就可以把他们序列化来完成.

仅仅是把对象从堆内存存储到了硬盘上.

 

接口 Serializable

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联. 该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。(当一个对象进行序列化的时候,给该类分配一个id号.这个id号可以用来验证.你给给我的文件存储的对象和你给我的类到底是不是同一版本的啊….)

 

这个ID号是根据类的特征和类的签名算出来的.为什么ID号那么长,是因为为了避免重复.

所以Serializable是给类加上id用的. 用于判断类和对象是否是同一个版本。

 

如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值. 原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。

 

在学web的时候一些类就需要实现序列化接口,因为服务器就会对你的对象进行临时本地存储.它怕服务器崩了的以后,你的会话都被消失了.所以存储在了硬盘上,你重新启动服务器会恢复之前的会话,恢复对象,你之前运行的东西都在.

 

 

我们编写一个实现了Serializable接口（序列化标志接口）的类， Eclipse马上就会给一个黄色警告：需要增加一个Serial Version ID。为什么要增加？它是怎么计算出来的？有什么用？本章就来解释该问题。

类实现Serializable接口的目的是为了可持久化，比如网络传输或本地存储，为系统的分布和异构部署提供先决支持条件。若没有序列化，现在我们熟悉的远程调用、对象数据库都不可能存在，我们来看一个简单的序列化类：

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

这是一个简单JavaBean，实现了Serializable接口，可以在网络上传输，也可以本地存储然后读取。这里我们以Java消息服务（Java Message Service）方式传递该对象（即通过网络传递一个对象），定义在消息队列中的数据类型为ObjectMessage，首先定义一个消息的生产者（Producer），代码如下：

1 public class Producer {  
2     public static void main(String[] args) throws Exception {  
3           Person person = new Person();  
4           person.setName("混世魔王");6           //序列化，保存到磁盘上  
7           SerializationUtils.writeObject(person);  
8     }  
9 } 

这里引入了一个工具类SerializationUtils，其作用是对一个类进行序列化和反序列化，并存储到硬盘上（模拟网络传输），其代码如下：

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 import java.io.ObjectInput;
 4 import java.io.ObjectInputStream;
 5 import java.io.ObjectOutputStream;
 6 import java.io.Serializable;
 7 
 8 public class SerializationUtils {  
 9     private static String FILE_NAME = "c:/obj.bin";  
10     // 序列化  
11     public static void writeObject(Serializable s) {  
12        try {  
13            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));  
14            oos.writeObject(s);  
15            oos.close();  
16        } catch (Exception e) {  
17            e.printStackTrace();  
18        }  
19    }  
20      
21    public static Object readObject(){  
22        Object obj=null;  
23        // 反序列化  
24        try {  
25            ObjectInput input = new ObjectInputStream(new FileInputStream(FILE_NAME));  
26            obj = input.readObject();  
27            input.close();  
28        } catch (Exception e) {  
29            e.printStackTrace();  
30        }  
31        return obj;  
32    }  
33 } 

通过对象序列化过程，把一个对象从内存块转化为可传输的数据流，然后通过网络发送到消息消费者（Consumer）那里，并进行反序列化，生成实例对象，代码如下：.

1 public class Consumer {  
2     public static void main(String[] args) throws Exception {  
3           // 反序列化  
4           Person p = (Person) SerializationUtils.readObject();  
5           System.out.println("name="+p.getName());
6     }  
7 } 

这是一个反序列化过程，也就是对象数据流转换为一个实例对象的过程，其运行后的输出结果为：混世魔王。这太easy了，是的，这就是序列化和反序列化典型的demo。但此处隐藏着一个问题：如果消息的生产者和消息的消费者所参考的类（Person类）有差异，会出现何种神奇事件？比如：消息生产者中的Person类增加了一个年龄属性，而消费者没有增加该属性。为啥没有增加？！因为这是个分布式部署的应用，你甚至都不知道这个应用部署在何处，特别是通过广播（broadcast）方式发送消息的情况，漏掉一两个订阅者也是很正常的。

这个时候给Person.java类增加一个age属性.

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

直接运行Consumer.java 会抛出 java.io.InvalidClassException异常

 1 java.io.InvalidClassException: com.summerchill.staticproxy.Person; local class incompatible: stream classdesc serialVersionUID = 7107224374967840269, local class serialVersionUID = -6034120172421752969
 2     at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
 3     at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
 4     at java.io.ObjectInputStream.readClassDesc(Unknown Source)
 5     at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
 6     at java.io.ObjectInputStream.readObject0(Unknown Source)
 7     at java.io.ObjectInputStream.readObject(Unknown Source)
 8     at com.summerchill.staticproxy.SerializationUtils.readObject(SerializationUtils.java:28)
 9     at com.summerchill.staticproxy.Consumer.main(Consumer.java:6)
10 Exception in thread "main" java.lang.NullPointerException
11     at com.summerchill.staticproxy.Consumer.main(Consumer.java:7)

在这种序列化和反序列化的类不一致的情形下，反序列化时会报一个InvalidClassException异常，原因是序列化和反序列化所对应的类版本发生了变化，JVM不能把数据流转换为实例对象。接着刨根问底：JVM是根据什么来判断一个类版本的呢？

好问题，通过SerialVersionUID，也叫做流标识符（Stream Unique Identifier），即类的版本定义的，它可以显式声明也可以隐式声明。显式声明格式如下：

1 private static final long serialVersionUID = XXXXXL; 

而隐式声明则是我不声明，你编译器在编译的时候帮我生成。生成的依据是通过包名、类名、继承关系、非私有的方法和属性，以及参数、返回值等诸多因子计算得出的，极度复杂，基本上计算出来的这个值是唯一的。

serialVersionUID如何生成已经说明了，我们再来看看serialVersionUID的作用。JVM在反序列化时，会比较数据流中的serialVersionUID与类的serialVersionUID是否相同，如果相同，则认为类没有发生改变，可以把数据流load为实例对象；如果不相同，对不起，我JVM不干了，抛个异常InvalidClassException给你瞧瞧。这是一个非常好的校验机制，可以保证一个对象即使在网络或磁盘中“滚过”一次，仍能做到“出淤泥而不染”，完美地实现类的一致性。

但是，有时候我们需要一点特例场景，例如：我的类改变不大，JVM是否可以把我以前的对象反序列化过来？就是依靠显式声明serialVersionUID，向JVM撒谎说“我的类版本没有变更”，如此，我们编写的类就实现了向上兼容。我们修改一下上面的Person类，代码如下：

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

Person.java类上加上了serialVersionUID之后再进行序列化的Producer.java和反序列化的Consumer.java之后

是不会抛出InvalidClassException异常的.

刚开始生产者和消费者持有的Person类版本一致，都是V1.0，某天生产者的Person类版本变更了，增加了一个“年龄”属性，升级为V2.0，而由于种种原因（比如程序员疏忽、升级时间窗口不同等）消费端的Person还保持为V1.0版本，代码如下：

 1 public class Person implements Serializable{      
 2     private static final long serialVersionUID = -6034120172421752969L;
 3     private String name;
 4     private int age;
 5     public int getAge() {
 6         return age;
 7     }
 8 
 9     public void setAge(int age) {
10         this.age = age;
11     }
12 
13     public String getName() {
14         return name;
15     }
16 
17     public void setName(String name) {
18         this.name = name;
19     }  
20 } 

此时虽然生产者和消费者对应的类版本不同，但是显式声明的serialVersionUID相同，反序列化也是可以运行的，所带来的业务问题就是消费端不能读取到新增的业务属性（age属性）而已。

通过此例，我们的反序列化实现了版本向上兼容的功能，使用V1.0版本的应用访问了一个V2.0版本的对象，这无疑提高了代码的健壮性。我们在编写序列化类代码时，随手加上serialVersionUID字段，也不会给我们带来太多的工作量，但它却可以在关键时候发挥异乎寻常的作用。

注意　显式声明serialVersionUID可以避免对象不一致，但尽量不要以这种方式向JVM“撒谎”。