开发者社区> 小金子> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

java-Java可以对方法进行序列化?

简介: Java序列化与反序列化是什么?为什么需要序列化与反序列化?如何实现Java序列化与反序列化?本文围绕这些问题进行了探讨。  1.Java序列化与反序列化  Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。
+关注继续查看

Java序列化与反序列化是什么?为什么需要序列化与反序列化?如何实现Java序列化与反序列化?本文围绕这些问题进行了探讨。

 1.Java序列化与反序列化

 Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。

 2.为什么需要序列化与反序列化

 我们知道,当两个进程进行远程通信时,可以相互发送各种类型的数据,包括文本、图片、音频、视频等, 而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时,能否实现进程间的对象传送呢?答案是可以的。如何做到呢?这就需要Java序列化与反序列化了。换句话说,一方面,发送方需要把这个Java对象转换为字节序列,然后在网络上传送;另一方面,接收方需要从字节序列中恢复出Java对象。

 当我们明晰了为什么需要Java序列化和反序列化后,我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化,通过序列化可以把数据永久地保存到硬盘上(通常存放在文件里),二是,利用序列化实现远程通信,即在网络上传送对象的字节序列。

3.如何实现Java序列化与反序列化

1)JDK类库中序列化API

 java.io.ObjectOutputStream:表示对象输出流

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

java.io.ObjectInputStream:表示对象输入流

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

2)实现序列化的要求

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

3)实现Java对象序列化与反序列化的方法

假定一个Student类,它的对象需要序列化,可以有如下三种方法:

方法一:若Student类仅仅实现了Serializable接口,则可以按照以下方式进行序列化和反序列化

ObjectOutputStream采用默认的序列化方式,对Student对象的非transient的实例变量进行序列化。

ObjcetInputStream采用默认的反序列化方式,对对Student对象的非transient的实例变量进行反序列化。

方法二:若Student类仅仅实现了Serializable接口,并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out),则采用以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。

ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

方法三:若Student类实现了Externalnalizable接口,且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法,则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。

ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

4)JDK类库中序列化的步骤

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

ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(“D:\\objectfile.obj”));

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

out.writeObject(“Hello”);

out.writeObject(new Date());

5)JDK类库中反序列化的步骤

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

ObjectInputStream in = new ObjectInputStream(new fileInputStream(“D:\\objectfile.obj”));

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

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

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

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

为了更好地理解Java序列化与反序列化,选择方法一编码实现。

Student类定义如下:

[java] view plain copy
  1. package com.jieke.io;  
  2. import java.io.Serializable;  
  3.   

  4. public class Student implements Serializable  
  5. {  
  6.  private String name;  
  7.  private char sex;  
  8.  private int year;  
  9.  private double gpa;  
  10.   
  11.  public Student()  
  12.  {  
  13.   
  14.  }  
  15.  public Student(String name,char sex,int year,double gpa)  
  16.  {  
  17.   this.name = name;  
  18.   this.sex = sex;  
  19.   this.year = year;  
  20.   this.gpa = gpa;  
  21.  }  
  22.   
  23.  public void setName(String name)  
  24.  {  
  25.   this.name = name;  
  26.  }  
  27.   
  28.  public void setSex(char sex)  
  29.  {  
  30.   this.sex = sex;  
  31.  }  
  32.   
  33.  public void setYear(int year)  
  34.  {  
  35.   this.year = year;  
  36.  }  
  37.   
  38.  public void setGpa(double gpa)  
  39.  {  
  40.   this.gpa = gpa;  
  41.  }  
  42.   
  43.  public String getName()  
  44.  {  
  45.   return this.name;  
  46.  }  
  47.    
  48.  public char getSex()  
  49.  {  
  50.   return this.sex;  
  51.  }  
  52.   
  53.  public int getYear()  
  54.  {  
  55.   return this.year;  
  56.  }  
  57.   
  58.  public double getGpa()  
  59.  {  
  60.   return this.gpa;  
  61.  }  
  62. }  

把Student类的对象序列化到文件O:\\Java\\com\\jieke\\io\\student.txt,并从该文件中反序列化,向console显示结果。代码如下:

[java] view plain copy
  1. import java.io.*;  
  2.   

  3.   
  4. public class UseStudent  
  5. {  
  6.  public static void main(String[] args)  
  7.  {  
  8.   Student st = new Student("Tom",'M',20,3.6);  
  9.   File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");  
  10.   try  
  11.   {  
  12.    file.createNewFile();  
  13.   }  
  14.   catch(IOException e)  
  15.   {  
  16.    e.printStackTrace();  
  17.   }  
  18.   try  
  19.   {  
  20.    //Student对象序列化过程  
  21.    FileOutputStream fos = new FileOutputStream(file);  
  22.    ObjectOutputStream oos = new ObjectOutputStream(fos);  
  23.    oos.writeObject(st);  
  24.    oos.flush();  
  25.    oos.close();  
  26.    fos.close();  
  27.   
  28.    //Student对象反序列化过程  
  29.    FileInputStream fis = new FileInputStream(file);  
  30.    ObjectInputStream ois = new ObjectInputStream(fis);  
  31.    Student st1 = (Student) ois.readObject();  
  32.    System.out.println("name = " + st1.getName());  
  33.    System.out.println("sex = " + st1.getSex());  
  34.    System.out.println("year = " + st1.getYear());  
  35.    System.out.println("gpa = " + st1.getGpa());  
  36.    ois.close();  
  37.    fis.close();  
  38.   }  
  39.   catch(ClassNotFoundException e)  
  40.   {  
  41.    e.printStackTrace();  
  42.   }  
  43.   catch (IOException e)  
  44.   {  
  45.    e.printStackTrace();  
  46.   }               
  47.  }  
  48. }  

结果如下所示:

name = Tom

sex = M

year = 20

gpa = 3.6

总结:

1)Java序列化就是把对象转换成字节序列,而Java反序列化就是把字节序列还原成Java对象。

2)采用Java序列化与反序列化技术,一是可以实现数据的持久化,在MVC模式中很是有用;二是可以对象数据的远程通信。


Java的序列化机制只序列化对象的属性值,而不会去序列化什么所谓的方法。 


其实这个问题简单思考一下就可以搞清楚,方法是不带状态的,就是一些指令,指令是不需要序列化的,只要你的JVM classloader可以load到这个类,那么类方法指令自然就可以获得。序列化真正需要保存的只是对象属性的值,和对象的类型。 

这些知识找一本Java基础编程的书,或者Java手册就可以查到,我以为是不应该犯这种基本概念错误的。 

我们可以做一个简单的小试验,来证实一下: 

Java代码  收藏代码
  1. package com.javaeye;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class DomainObject  implements Serializable {  
  6.   
  7.     private String name;  
  8.       
  9.     private int age ;  
  10.   
  11.     public int getAge(); {  
  12.         return age;  
  13.     }  
  14.   
  15.     public void setAge(int age); {  
  16.         this.age = age;  
  17.     }  
  18.   
  19.     public String getName(); {  
  20.         return name;  
  21.     }  
  22.   
  23.     public void setName(String name); {  
  24.         this.name = name;  
  25.     }  
  26.       
  27.       
  28. }  



Java代码  收藏代码
  1. package com.javaeye;  
  2.   
  3. import java.io.FileOutputStream;  
  4. import java.io.ObjectOutputStream;  
  5.   
  6. public class Main {  
  7.   
  8.     public static void main(String[] args); throws Exception {  
  9.         DomainObject obj = new DomainObject();;  
  10.         obj.setAge(29);;  
  11.         obj.setName("fankai");;  
  12.         FileOutputStream fos = new FileOutputStream("DomainObject");;  
  13.         ObjectOutputStream oos = new ObjectOutputStream(fos);;  
  14.         oos.writeObject(obj);;  
  15.         oos.close();;  
  16.         fos.close();;  
  17.     }  
  18.   
  19. }  



DomainObject是我们准备序列化的类,在Main里面,我们new一个DomainObject的对象,然后赋值,最后把该对象序列化到一个硬盘文件中。 

然后使用一种支持二进制编辑器,例如UltraEdit打开这个文件,看看Java都对DomainObject序列化了哪些信息,你就什么都明白了。 

为了更方便观察,我使用Linux下面的strings去提取文本信息,输出为: 

root@linux:~> strings DomainObject 
com.javaeye.DomainObject 
ageL 
namet 
Ljava/lang/String;xp 
fankai 

这些信息很直观的告诉我们序列化都保存了些什么内容: 
1)对象的类型 
2)对象属性的类型 
3)对象属性的值 

并没有什么方法签名的信息,更不要说什么序列化方法了。 

然后我们再做一个试验,给DomainObject增加两个方法: 
Java代码  收藏代码
  1. package com.javaeye;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class DomainObject  implements Serializable {  
  6.   
  7.     private String name;  
  8.       
  9.     private int age ;  
  10.   
  11.     public int getAge(); {  
  12.         return age;  
  13.     }  
  14.   
  15.     public void setAge(int age); {  
  16.         this.age = age;  
  17.     }  
  18.   
  19.     public String getName(); {  
  20.         return name;  
  21.     }  
  22.   
  23.     public void setName(String name); {  
  24.         this.name = name;  
  25.     }  
  26.       
  27.     public String toString(); {  
  28.         return "This is a serializable test!";  
  29.     }  
  30.       
  31.     public void doSomeWork(); {  
  32.         System.out.println("hello");;  
  33.     }  
  34. }  


我们增加了toString方法和doSomeWork方法,按照你的理论,如果序列化方法的话,产生的文件体积必然增大。记录一下文件体积,92Byte,好了,删除,运行程序,生成了新的文件,看一下体积,还是92Byte! 

拿到Linux下面再提取一下字符串: 

root@linux:~> strings DomainObject 
com.javaeye.DomainObject 
ageL 
namet 
Ljava/lang/String;xp 
fankai 

完全一模一样! 

然后我们再做第三个试验,这次把DomainObject的两个属性以及相关方法删除掉: 
Java代码  收藏代码
  1. package com.javaeye;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class DomainObject  implements Serializable {  
  6.   
  7.     public String toString(); {  
  8.         return "This is a serializable test!";  
  9.     }  
  10.       
  11.     public void doSomeWork(); {  
  12.         System.out.println("hello");;  
  13.     }  
  14. }  


修改Main类如下: 

Java代码  收藏代码
  1. package com.javaeye;  
  2.   
  3. import java.io.FileOutputStream;  
  4. import java.io.ObjectOutputStream;  
  5.   
  6. public class Main {  
  7.   
  8.     public static void main(String[] args); throws Exception {  
  9.         DomainObject obj = new DomainObject();;  
  10.   
  11.         FileOutputStream fos = new FileOutputStream("DomainObject");;  
  12.         ObjectOutputStream oos = new ObjectOutputStream(fos);;  
  13.         oos.writeObject(obj);;  
  14.         oos.close();;  
  15.         fos.close();;  
  16.     }  
  17.   
  18. }  


如果序列化方法的话,我们必然应该在文件里面发现方法的签名信息,甚至方法里面包含的字符串,好了,再运行一遍,然后打开看一下吧!文件现在体积变成了45Byte,拿到Linux下面提取一下信息: 

root@linux:~> strings DomainObject 
com.javaeye.DomainObject 

只有对象的类型信息,再无其它东西了! 

请记住序列化机制只保存对象的类型信息,属性的类型信息和属性值,和方法没有什么关系,你就是给这个类增加10000个方法,序列化内容也不会增加任何东西

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
java156-序列化
java156-序列化
0 0
Java对象与Java类(下)
Java对象与Java类(下)
0 0
Java对象与Java类(上)
Java对象与Java类(上)
0 0
为什么不建议使用 Java 自带的序列化?
谈到序列化我们自然想到 Java 提供的 Serializable 接口,在 Java 中我们如果需要序列化只需要继承该接口就可以通过输入输出流进行序列化和反序列化。
0 0
关于 Java 序列化你不知道的 5 件事
您觉得自己懂 Java 编程?事实上,大多数程序员对于 Java 平台都是浅尝则止,只学习了足以完成手头上任务的知识而已。在本系列 中,Ted Neward 深入挖掘 Java 平台的核心功能,揭示一些鲜为人知的事实,帮助您解决最棘手的编程挑战。
0 0
SerializeUtil 序列化 java
SerializeUtil  序列化  java   import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.
769 0
java中的序列化
java中的序列化是一个很有意思的接口,只需要声明而无需做额外的工作,但是在虚拟机内部却做了大量的工作保证了这一特点。只要对象实现了序列化接口,就会把它转换为一个字节序列,当需要的时候能够把这个字节序列完全恢复为原来的对象。
387 0
Java的序列化问题
数据在不同的系统间传递,需要将其序列化。 即将Java转换成为byte[]然后利用soceket通信。收到后再反序列化将byte[]——>java。
409 0
+关注
小金子
热爱分布式技术
文章
问答
文章排行榜
最热
最新
相关电子书
更多
OpenCrypto Unchaining the Java
立即下载
Java Your(Next)
立即下载
Java开发手册1.4.0
立即下载