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

java序列化和反序列化以及序列化ID的作用分析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文件。

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

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

        

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

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

         

        我们再写个方法来反序列化该字节成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 序列化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. }  



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

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

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

      

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


总结:

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


版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/150453.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • UEditor前端配置项说明

    UEditor前端配置项说明

  • Unity与 SO 交互 ☀️| 详细讲解 怎样通过 Android Studio 生成一个.so文件 并简单调用!

    Unity与 SO 交互 ☀️| 详细讲解 怎样通过 Android Studio 生成一个.so文件 并简单调用!本文章是Unity与SO交互的内容,详细的将每一步都做了介绍,生成一个so文件其实很简单!该专栏还有多篇优质内容在等待你观看。

  • IDEA热部署无效

    IDEA热部署无效遇到这样的问题,我觉既不是没有设置“更新类和资源”,也不是啥插件问题而是没有以debug模式运行!!以run模式运行的话热部署是不起作用的。

  • 深入浅出JVM调优,看完你就懂

    深入浅出JVM调优,看完你就懂深入浅出JVM调优基本概念:JVM把内存区分为堆区(heap)、栈区(stack)和方法区(method)。由于本文主要讲解JVM调优,因此我们可以简单的理解为,JVM中的堆区中存放的是实际的对象,是需要被GC的。其他的都无需GC。下图文JVM的内存模型从图中我们可以看到,1、JVM实质上分为三大块,年轻代(YoungGen),年老代(OldMemory…

  • 利用XLSTransformer生成excel「建议收藏」

    利用XLSTransformer生成excel「建议收藏」XLSTransformertransformer=newXLSTransformer();StringdistFile=System.getProperty("java.io.tmpdir")+"/"+fileName+".xls";Filetemplate=ResourceUtils.getFile("classpath:…

  • Java类的三大特性总结

    Java类的三大特性总结类的三大特性包括:封装、继承、多态一、封装1.含义:封装就是把同一类事物的共性(包括属性和方法)归到同一类中,方便使用。封装和继承几乎都是为多态而准备的。封装也称信息隐藏,是指利用抽象数据类型把数据和基于数据的操作封装起来,使其成为一个不可分割的整体,数据隐藏在抽象数据内部,尽可能的隐藏数据细节,只保留一些接口使其与外界发生联系。也就是说用户无需知道内部的数据和方法的具体实现…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号