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)
blank

相关推荐

  • 获取窗口句柄 c语言,VC++编程获取窗口句柄的方法小结分享「建议收藏」

    获取窗口句柄 c语言,VC++编程获取窗口句柄的方法小结分享「建议收藏」—-想了解VC++编程获取窗口句柄的方法小结分享的全部内容且更多的C语言教程关注VC++编程获取窗口句柄的方法小结分享实例讲述了VC++编程获取窗口句柄的方法。分享给大家供大家参考,具体如下:在VC++编程中常需获取控件或窗体句柄,下面总结了几种方法,还希望大家能多多补充。1、自身窗口句柄可用AfxGetMainWnd获取。2、系统中其他APP的窗口句柄可用FindWindow获取(用SPY帮一下…

  • 如何启用计算机双通道内存的方法,内存条怎么插 组建内存双通道正确插法教程…

    如何启用计算机双通道内存的方法,内存条怎么插 组建内存双通道正确插法教程…当我们安装或升级内存时,发现主板上有四个内存插槽,所以不知道该插入哪个内存插槽。事实上,理论上,任何一个内存插槽都可以正常使用。但是如果随意插上,未必能搭建双通道,搭建双通道也是有讲究的。那么双通道内存是什么意思呢?怎么安装?下面,安装者之家将为大家普及双通道内存的知识,并附上正确插入双通道内存的教程。希望这篇文章能对大家有所帮助。设置内存双通道插入教程一、双通道内存是什么意思?有什么好处?我们知…

  • 焦点科技怎么老是招人_为什么口腔老是溃疡 严重口腔溃疡怎么治「建议收藏」

    焦点科技怎么老是招人_为什么口腔老是溃疡 严重口腔溃疡怎么治「建议收藏」口腔溃疡作为最常见的口腔疾病日益引起人们的重视,很多患者的口腔溃疡由于得不到有效的治疗而变成复发性口腔溃疡,其中有20%的复发性口腔溃疡患者久治不愈引发白塞氏病。那么,为什么口腔老是溃疡,严重口腔溃疡怎么治呢?下面我们就来看看口腔黏膜专家的介绍。引起口腔溃疡的原因有很多1、免疫力下降许多的口腔溃疡患者总是在感冒时,口腔溃疡也同时会反反复作,而这个时候身体的抵抗力差,所以患者在治疗感冒的过程中,也不…

  • WEB/HTTP服务器搭建[通俗易懂]

    WEB/HTTP服务器搭建[通俗易懂]HTTP对于软件都有服务和客户,有服务端和客户端服务就是在操作系统运行一个或者多个程序,并为客户端提供相应所需的服务协议就是计算机网络中进行数据交换而建立的规则、标准或约定的集合。只有遵守这个约定,计算机之间才能相互通信交流。它的三要素是:语法、语义、时序。1.WEB服务器web服务器一般指网站服务器,他是一个驻留于Internet的一个计算机程序,用于向浏览器提供文档…

  • #标题 已知从键盘上任意输入一个3位整数,编译计算并输出它的逆序数

    #标题 已知从键盘上任意输入一个3位整数,编译计算并输出它的逆序数

  • 股票历史数据下载接口汇总(动态更新)

    歪枣网上提供股票历史数据下载接口汇总,实时动态更新接口名称 Api接口 接口描述 A股列表 getStockHSABaseInfo 沪深A股基本信息 每日行情 getStockHSADailyMarket 沪深A股每日行情数据 实时数据 getStockHSAMinuteKLine 沪深A股实时数据,提供30个交易日内的每日实时交易数据,数据以分钟为粒度。 时线数据 getStockHSAHourKLine 沪深A股分时数据,提供30个交易日内的5分钟、15分钟、30分钟、60分钟数据。 日线数

发表回复

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

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