java序列化和反序列化以及序列化ID的作用分析

 java序列化和反序列化

一、概念

       java对象序列化的意思就是将对象的状态转化成字节流,以后可以通过这些值再生成相同状态的对象。对象序列化是对象持久化的一种实现方法,它是将对象的属性和方法转化为一种序列化的形式用于存储和传输。反序列化就是根据这些保存的信息重建对象的过程。

       序列化:将java对象转化为字节序列的过程。

       反序列化:将字节序列转化为java对象的过程。


二、为什么要序列化和反序列化

       我们知道,当两个进程进行远程通信时,可以相互发送各种类型的数据,包括文本、图片、音频、视频等, 而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时,能否实现进程间的对象传送呢?答案是可以的。如何做到呢?这就需要Java序列化与反序列化了。换句话说,一方面,发送方需要把这个Java对象转换为字节序列,然后在网络上传送;另一方面,接收方需要从字节序列中恢复出Java对象。当我们明晰了为什么需要Java序列化和反序列化后,我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化,通过序列化可以把数据永久地保存到硬盘上(通常存放在文件里),二是,利用序列化实现远程通信,即在网络上传送对象的字节序列。


三、涉及到的javaAPI 

          java.io.ObjectOutputStream表示对象输出流,它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。

          java.io.ObjectInputStream表示对象输入流,它的readObject()方法源输入流中读取字节序列,再把它们反序列化成为一个对象,并将其返回。

         只有实现了Serializable或Externalizable接口的类的对象才能被序列化,否则抛出异常。


四、序列化和反序列化的步骤

         序列化:

           步骤一:创建一个对象输出流,它可以包装一个其它类型的目标输出流,如文件输出流:

                          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“目标地址路径”));

         步骤二:通过对象输出流的writeObject()方法写对象:

                          out.writeObject("Hello");

                          out.writeObject(new Date());

         反序列化:        

          步骤一:创建一个对象输入流,它可以包装一个其它类型输入流,如文件输入流:

                          ObjectInputStream in = new ObjectInputStream(new fileInputStream(“目标地址路径”));

         步骤二:通过对象输出流的readObject()方法读取对象:

                        String obj1 = (String)in.readObject();

                        Date obj2 =  (Date)in.readObject();

        说明:为了正确读取数据,完成反序列化,必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。

五、举个例子

       我们首先写个Person实现Serializable接口:

[java] view plain copy
 print?
  1. import java.io.Serializable;  
  2.   
  3. /** 
  4.  *  
  5.  * 测试序列化和反序列化 
  6.  * @author crazyandcoder 
  7.  * @date [2015-8-5 上午11:14:32] 
  8.  */  
  9. public class Person implements Serializable  {  
  10.       
  11.     private int age;  
  12.     private String name;  
  13.     //序列化ID  
  14.     private static final long serialVersionUID = -5809782578272943999L;  
  15.       
  16.     public Person() {}  
  17.       
  18.     public int getAge() {  
  19.         return age;  
  20.     }  
  21.     public void setAge(int age) {  
  22.         this.age = age;  
  23.     }  
  24.     public String getName() {  
  25.         return name;  
  26.     }  
  27.     public void setName(String name) {  
  28.         this.name = name;  
  29.     }  
  30.   
  31. }  

        

         其次,我们在main()里面写个方法,执行序列化过程:

[java] view plain copy
 print?
  1. import java.io.FileNotFoundException;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.ObjectOutputStream;  
  5. /** 
  6.  *  
  7.  * 测试序列化和反序列化 
  8.  * @author crazyandcoder 
  9.  * @date [2015-8-5 上午11:16:14] 
  10.  */  
  11. public class ObjSerializeAndDeserializeTest {   
  12.     public static void main(String[] args) {  
  13.           
  14.         //将Person对象序列化  
  15.         SerializePerson();  
  16.   
  17.     }  
  18.       
  19.     /** 
  20.      *  
  21.      * @author crazyandcoder 
  22.      * @Title: 序列化Person对象,将其存储到 E:/hello.txt文件中 
  23.      * @param   
  24.      * @return void  
  25.      * @throws  
  26.      * @date [2015-8-5 上午11:21:27] 
  27.      */  
  28.     private static void SerializePerson() {  
  29.         Person person =new Person();  
  30.         person.setAge(30);  
  31.         person.setName("SerializePerson");  
  32.         ObjectOutputStream outputStream = null;  
  33.         try {  
  34.             outputStream=new ObjectOutputStream(new FileOutputStream("E:/hello.txt"));  
  35.             outputStream.writeObject(person);  
  36.             System.out.println("序列化成功。");  
  37.         } catch (FileNotFoundException e) {  
  38.             e.printStackTrace();              
  39.         } catch (IOException e) {  
  40.             e.printStackTrace();          
  41.         } finally {  
  42.             try {  
  43.                 outputStream.close();  
  44.             } catch (IOException e) {  
  45.                 e.printStackTrace();  
  46.             }  
  47.         }         
  48.     }  
  49. }  
          代码很简单,首先创建一个对象输出流ObjectOutputStream,它可以包装一个其它类型的目标输出流,如文件输出流FileOutputStream,并指定存储的位置为“E:/hello.txt”,然后通过对象输出流的writeObject()方法写对象便执行了序列化过程。运行看一下效果,正确的话便会在控制台打印“”,并且在本地E盘下会创建一个Hello.txt文件。



        

        我们查看一下hello.txt文件中的内容,里面是一串字节序列,打开该文件的时候不要用自带的记事本打开,因为涉及到字符编码的问题,所以显示的话是一串乱码,建议用SublimeText打开。


         

        我们再写个方法来反序列化该字节成Person对象,并打印出里面的值。

[java] view plain copy
 print?
  1. import java.io.FileInputStream;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.ObjectInputStream;  
  6. import java.io.ObjectOutputStream;  
  7. /** 
  8.  *  
  9.  * 测试序列化和反序列化 
  10.  * @author crazyandcoder 
  11.  * @date [2015-8-5 上午11:16:14] 
  12.  */  
  13. public class ObjSerializeAndDeserializeTest {  
  14.   
  15.        
  16.     public static void main(String[] args) {  
  17.           
  18.         //反序列化生成Person对象  
  19.         Person person=DeserializePerson();  
  20.         System.out.println("name :"+person.getName());  
  21.         System.out.println("age  :"+person.getAge());  
  22.           
  23.   
  24.     }  
  25.       
  26.     /** 
  27.      * 执行反序列化过程生产Person对象 
  28.      * @author crazyandcoder 
  29.      * @Title: DeserializePerson  
  30.      * @param @return  
  31.      * @return Person  
  32.      * @throws  
  33.      * @date [2015-8-5 下午1:30:12] 
  34.      */  
  35.     private static Person DeserializePerson() {  
  36.           
  37.         Person person=null;  
  38.         ObjectInputStream inputStream=null;  
  39.         try {  
  40.             inputStream=new ObjectInputStream(new FileInputStream("E:/hello.txt"));  
  41.             try {  
  42.                 person=(Person)inputStream.readObject();  
  43.                 System.out.println("执行反序列化过程成功。");  
  44.             } catch (ClassNotFoundException e) {  
  45.                 e.printStackTrace();  
  46.             }  
  47.         } catch (FileNotFoundException e) {  
  48.             e.printStackTrace();  
  49.         } catch (IOException e) {  
  50.             e.printStackTrace();  
  51.         } finally {  
  52.             try {  
  53.                 inputStream.close();  
  54.             } catch (IOException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.         return person;  
  59.     }  
  60. }  

         

        执行反序列化的代码也是很简单的,首先创建一个输入流对象ObjectInputStream,然后从指定的目录下“E:/hello.txt”获取它的字节序列,然后通过输入流对象的readObject()方法将其获得的对象强制转化为Person对象,这就完成了反序列化工作,正确的反序列化成功的情况下控制台打印输出为:



Java 序列化ID的作用


       有关序列化和反序列化的概念,可以查看前一篇java序列化和反序列化使用总结的讲解,这一篇主要说明一下序列化过程中出现的问题即java序列化和反序列化中ID的作用。

        在前一篇的介绍中,我们在代码里会发现有这样一个变量:serialVersionUID,那么这个变量serialVersionUID到底具有什么作用呢?能不能去掉呢?


[java] view plain copy
 print?
  1. public class Person implements Serializable  {  
  2.       
  3.     private int age;  
  4.     private String sex;  
  5.     private String name;  
  6.     private String hobby;  
  7.     //序列化ID  
  8.     private static final long serialVersionUID = -5809782578272943999L;  
  9.         ............  
  10.   
  11. }  
       

       序列化ID的作用:  

       其实,这个序列化ID起着关键的作用,它决定着是否能够成功反序列化!简单来说,java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时,JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较,如果相同则认为是一致的,便可以进行反序列化,否则就会报序列化版本不一致的异常。等会我们可以通过代码验证一下。

       序列化ID如何产生:

       当我们一个实体类中没有显示的定义一个名为“serialVersionUID”、类型为long的变量时,Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较,这种情况下,只有同一次编译生成的class才会生成相同的serialVersionUID。譬如,当我们编写一个类时,随着时间的推移,我们因为需求改动,需要在本地类中添加其他的字段,这个时候再反序列化时便会出现serialVersionUID不一致,导致反序列化失败。那么如何解决呢?便是在本地类中添加一个“serialVersionUID”变量,值保持不变,便可以进行序列化和反序列化。


       验证“serialVersionUID”不一致导致反序列化失败

[java] view plain copy
 print?
  1. import java.io.Serializable;  
  2.   
  3. /** 
  4.  *  
  5.  * 测试序列化和反序列化 
  6.  * @author crazyandcoder 
  7.  * @date [2015-8-5 上午11:14:32] 
  8.  */  
  9. public class Person implements Serializable  {  
  10.       
  11.     private int age;  
  12. //  private String sex;  
  13. //  private String name;  
  14. //  private String hobby;  
  15.     //序列化ID  
  16. //  private static final long serialVersionUID = -5809782578272943999L;  
  17.       
  18. //  public String getHobby() {  
  19. //      return hobby;  
  20. //  }  
  21. //  
  22. //  public void setHobby(String hobby) {  
  23. //      this.hobby = hobby;  
  24. //  }  
  25.   
  26.     public Person() {}  
  27.       
  28.     public int getAge() {  
  29.         return age;  
  30.     }  
  31.       
  32.     public void setAge(int age) {  
  33.         this.age = age;  
  34.     }  
  35.       
  36. //  public String getSex() {  
  37. //      return sex;  
  38. //  }  
  39. //  
  40. //  public void setSex(String sex) {  
  41. //      this.sex = sex;  
  42. //  }  
  43.       
  44. //  public String getName() {  
  45. //      return name;  
  46. //  }  
  47. //  public void setName(String name) {  
  48. //      this.name = name;  
  49. //  }  
  50.   
  51. }  
        复用前篇使用到的代码,首先,我们生成一个本地Person类,里面添加一个字段age,然后将其序列化存于本地E:/hello.txt中,

[java] view plain copy
 print?
  1. import java.io.FileNotFoundException;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.ObjectOutputStream;  
  5.   
  6.   
  7. /** 
  8.  *  
  9.  * 测试序列化和反序列化 
  10.  * @author crazyandcoder 
  11.  * @date [2015-8-5 上午11:16:14] 
  12.  */  
  13. public class ObjSerializeAndDeserializeTest {  
  14.   
  15.        
  16.     public static void main(String[] args) {  
  17.           
  18.         //将Person对象序列化  
  19.         SerializePerson();  
  20.     }  
  21.       
  22.       
  23.     /** 
  24.      *  
  25.      * @author crazyandcoder 
  26.      * @Title: 序列化Person对象,将其存储到 E:/hello.txt文件中 
  27.      * @param   
  28.      * @return void  
  29.      * @throws  
  30.      * @date [2015-8-5 上午11:21:27] 
  31.      */  
  32.     private static void SerializePerson() {  
  33.         Person person =new Person();  
  34.         person.setAge(30);  
  35.         ObjectOutputStream outputStream = null;  
  36.         try {  
  37.             outputStream=new ObjectOutputStream(new FileOutputStream("E:/hello.txt"));  
  38.             outputStream.writeObject(person);  
  39.             System.out.println("序列化成功。");  
  40.         } catch (FileNotFoundException e) {  
  41.             e.printStackTrace();  
  42.                   
  43.         } catch (IOException e) {  
  44.             e.printStackTrace();  
  45.                   
  46.         } finally {  
  47.             try {  
  48.                 outputStream.close();  
  49.             } catch (IOException e) {  
  50.                 e.printStackTrace();  
  51.             }  
  52.         }  
  53.           
  54.     }  
  55. }  
        

        运行一下,会在控制台中打印“序列化成功。”,然后我们在Person类中再添加一个字段,name,然后直接从E:/hello.txt中反序列化,再运行一下,看看会出现什么问题。

[java] view plain copy
 print?
  1. import java.io.FileInputStream;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.ObjectInputStream;  
  6. import java.io.ObjectOutputStream;  
  7.   
  8. /** 
  9.  *  
  10.  * 测试序列化和反序列化 
  11.  *  
  12.  * @author crazyandcoder 
  13.  * @date [2015-8-5 上午11:16:14] 
  14.  */  
  15. public class ObjSerializeAndDeserializeTest {  
  16.   
  17.     public static void main(String[] args) {  
  18.   
  19.         // 反序列化生成Person对象  
  20.         Person person = DeserializePerson();  
  21.         System.out.println("name :" + person.getName());  
  22.         System.out.println("age  :" + person.getAge());  
  23.     }  
  24.   
  25.     /** 
  26.      * 执行反序列化过程生产Person对象 
  27.      *  
  28.      * @author crazyandcoder 
  29.      * @Title: DeserializePerson 
  30.      * @param @return 
  31.      * @return Person 
  32.      * @throws 
  33.      * @date [2015-8-5 下午1:30:12] 
  34.      */  
  35.     private static Person DeserializePerson() {  
  36.   
  37.         Person person = null;  
  38.         ObjectInputStream inputStream = null;  
  39.         try {  
  40.             inputStream = new ObjectInputStream(new FileInputStream("E:/hello.txt"));  
  41.             try {  
  42.                 person = (Person) inputStream.readObject();  
  43.                 System.out.println("执行反序列化过程成功。");  
  44.             } catch (ClassNotFoundException e) {  
  45.                 e.printStackTrace();  
  46.             }  
  47.         } catch (FileNotFoundException e) {  
  48.             e.printStackTrace();  
  49.         } catch (IOException e) {  
  50.             e.printStackTrace();  
  51.         } finally {  
  52.             try {  
  53.                 inputStream.close();  
  54.             } catch (IOException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.         return person;  
  59.     }  
  60. }  

       运行一下,不出意外,报了一个异常。



      

      从上面两张图便可以看出两次的序列化ID是不一样的,导致反序列化失败。


总结:

       虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID = 1L)。



没有更多推荐了,返回首页