Java对象序列化

序列化概述: 

    简单来说序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,流的概念这里不用多说(就是I/O),我们可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间(注:要想将对象传输于网络必须进行流化)!在对对象流进行读写操作时会引发一些问题,而序列化机制正是用来解决这些问题的! 

问题的引出: 

    如上所述,读写对象会有什么问题呢?比如:我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗?别急,其中一个最大的问题就是对象引用!举个例子来说:假如我有两个类,分别是A和B,B类中含有一个指向A类对象的引用,现在我们对两个类进行实例化{ A a = new A(); B b = new B(); },这时在内存中实际上分配了两个空间,一个存储对象a,一个存储对象b,接下来我们想将它们写入到磁盘的一个文件中去,就在写入文件时出现了问题!因为对象b包含对对象a的引用,所以系统会自动的将a的数据复制一份到b中,这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时,内存分配了三个空间,而对象a同时在内存中存在两份,想一想后果吧,如果我想修改对象a的数据的话,那不是还要搜索它的每一份拷贝来达到对象数据的一致性,这不是我们所希望的! 

以下序列化机制的解决方案: 

1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等) 

2.当要保存一个对象时,先检查该对象是否被保存了。 

3.如果以前保存过,只需写入"与已经保存的具有序列号x的对象相同"的标记,否则,保存该对象 

通过以上的步骤序列化机制解决了对象引用的问题! 

序列化的实现: 

    将需要被序列化的类实现Serializable接口,该接口没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的,然后使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。 

例子: 


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

import java.io.*; 

public class Test 

  public static void main(String[] args) 

  { 

    Employee harry = new Employee("Harry Hacker"50000); 

    Manager manager1 = new Manager("Tony Tester"80000); 

     manager1.setSecretary(harry); 

    

    Employee[] staff = new Employee[2]; 

    

    staff[0] = harry; 

    staff[1] = manager1; 

    try 

    { 

       ObjectOutputStream out = new ObjectOutputStream( 

         new FileOutputStream("employee.dat")); 

       out.writeObject(staff); 

       out.close(); 

      

       ObjectInputStream in = new ObjectInputStream( 

         new FileInputStream("employee.dat")); 

       Employee[] newStaff = (Employee[])in.readObject(); 

       in.close(); 

  

       /** 

       *通过harry对象来加薪 

       *将在secretary上反映出来 

       */ 

       newStaff[0].raiseSalary(10); 

      

       for (int i = 0; i < newStaff.length; i++) 

         System.out.println(newStaff[i]); 

    } 

    catch (Exception e) 

    { 

       e.printStackTrace(); 

    } 

  } 

  

class Employee implements Serializable 

  public Employee(String n, double s) 

  { 

    name = n; 

    salary = s; 

  } 

  

  /** 

   *加薪水 

   */ 

  public void raiseSalary(double byPercent) 

  { 

    double raise = salary * byPercent / 100

    salary += raise; 

  } 

  

  public String toString() 

  { 

    return getClass().getName() 

       + "[name = "+ name 

       + ",salary = "+ salary 

       + "]"

  } 

  

  private String name; 

  private double salary; 

class Manager extends Employee 

  public Manager(String n, double s) 

  { 

    super(n, s); 

    secretary = null

  } 

  

  /** 

   *设置秘书 

   */ 

  public void setSecretary(Employee s) 

  { 

    secretary = s; 

  } 

  

  public String toString() 

  { 

    return super.toString() 

       + "[secretary = "+ secretary 

       + "]"

  } 

  

  //secretary代表秘书 

  private Employee secretary; 

}

修改默认的序列化机制:  

   在序列化的过程中,有些数据字段我们不想将其序列化,对于此类字段我们只需要在定义时给它加上transient关键字即可,对于transient字段序列化机制会跳过不会将其写入文件,当然也不可被恢复。但有时我们想将某一字段序列化,但它在SDK中的定义却是不可序列化的类型,这样的话我们也必须把他标注为transient,可是不能写入又怎么恢复呢?好在序列化机制为包含这种特殊问题的类提供了如下的方法定义: 


1

2

3

4

private void readObject(ObjectInputStream in) throws 

     IOException, ClassNotFoundException; 

private void writeObject(ObjectOutputStream out) throws 

     IOException;

(注:这些方法定义时必须是私有的,因为不需要你显示调用,序列化机制会自动调用的) 

使用以上方法我们可以手动对那些你又想序列化又不可以被序列化的数据字段进行写出和读入操作。 

   下面是一个典型的例子,java.awt.geom包中的Point2D.Double类就是不可序列化的,因为该类没有实现Serializable接口,在我的例子中将把它当作LabeledPoint类中的一个数据字段,并演示如何将其序列化! 


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

import java.io.*; 

import java.awt.geom.*; 

public class TransientTest 

  public static void main(String[] args) 

  { 

    LabeledPoint label = new LabeledPoint("Book"5.005.00); 

    try 

    { 

       System.out.println(label);//写入前 

       ObjectOutputStream out = new ObjectOutputStream(new 

         FileOutputStream("Label.txt")); 

       out.writeObject(label); 

       out.close(); 

      

       System.out.println(label);//写入后 

      

       ObjectInputStream in = new ObjectInputStream(new 

         FileInputStream("Label.txt")); 

       LabeledPoint label1 = (LabeledPoint)in.readObject(); 

       in.close(); 

       System.out.println(label1);//读出并加1.0后 

    } 

    catch (Exception e) 

    { 

       e.printStackTrace(); 

    } 

  } 

  

class LabeledPoint implements Serializable 

  public LabeledPoint(String str, double x, double y) 

  { 

    label = str; 

    point = new Point2D.Double(x, y); 

  } 

  

  private void writeObject(ObjectOutputStream out) throws IOException 

  { 

    /** 

     *必须通过调用defaultWriteObject()方法来写入 

     *对象的描述以及那些可以被序列化的字段 

     */ 

     out.defaultWriteObject(); 

     out.writeDouble(point.getX()); 

     out.writeDouble(point.getY()); 

  } 

  

  private void readObject(ObjectInputStream in) 

    throws IOException, ClassNotFoundException 

  { 

    /** 

     *必须调用defaultReadObject()方法 

     */ 

     in.defaultReadObject(); 

    double x = in.readDouble() + 1.0

    double y = in.readDouble() + 1.0

    point = new Point2D.Double(x, y); 

  } 

  

  public String toString() 

  { 

    return getClass().getName() 

       + "[label = "+ label 

       + ", point.getX() = "+ point.getX() 

       + ", point.getY() = "+ point.getY() 

       + "]"

  } 

  

  private String label; 

  transient private Point2D.Double point; 

}

java序列化比较简单,通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从字节流恢复,不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意:不是每个类都可序列化,有些类是不能序列化的,例如涉及线程的类与特定JVM有非常复杂的关系。 

序列化机制: 

序列化分为两大部分:序列化和反序列化。序列化是这个过程的第一部分,将数据分解成字节流,以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示,有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接,包括对象类型和版本信息。反序列化时,JVM用头信息生成对象实例,然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述: 

处理对象流: 

(序列化过程和反序列化过程) 

 java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流,ObjectInputStream从字节流重构对象。 

  我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。 

writeObject()方法是最重要的方法,用于对象序列化。如果对象包含其他对象的引用,则writeObject()方法递归序列化这些对象。每个ObjectOutputStream维护序列化的对象引用表,防止发送同一对象的多个拷贝。(这点很重要)由于writeObject()可以序列化整组交叉引用的对象,因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时,进行反引用序列化,而不是再次写入对象字节流。 

下面,让我们从例子中来了解ObjectOutputStream这个类吧。 


1

2

3

4

5

6

1// 序列化 today's date 到一个文件中. 

2.    FileOutputStream f = new  FileOutputStream("tmp"); 

3.    ObjectOutputStream s = new  ObjectOutputStream(f); 

4.   s.writeObject("Today"); 

5.   s.writeObject(new  Date()); 

6.   s.flush();

  现在,让我们来了解ObjectInputStream这个类。它与ObjectOutputStream相似。它扩展DataInput接口。ObjectInputStream中的方法镜像DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码,而是包括类名及其签名。readObject()收到对象时,JVM装入头中指定的类。如果找不到这个类,则readObject()抛出ClassNotFoundException,如果需要传输对象数据和字节码,则可以用RMI框架。ObjectInputStream的其余方法用于定制反序列化过程。 

例子如下: 


1

2

3

4

5

1//从文件中反序列化 string 对象和 date 对象 

2.    FileInputStream in = new  FileInputStream("tmp"); 

3.    ObjectInputStream s = new  ObjectInputStream(in); 

4.    String today = (String)s.readObject(); 

5.    Date date = (Date)s.readObject();

定制序列化过程: 

序列化通常可以自动完成,但有时可能要对这个过程进行控制。java可以将类声明为serializable,但仍可手工控制声明为static或transient的数据成员。 

例子:一个非常简单的序列化类。 


1

2

3

4

1public class simpleSerializableClass  implements Serializable{ 

2.    String sToday="Today:"

3.    transient  Date dtToday=new  Date(); 

4. }

序列化时,类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后,序列化过程就无法将其加进对象字节流中,没有从transient数据成员发送的数据。后面数据反序列化时,要重建数据成员(因为它是类定义的一部分),但不包含任何数据,因为这个数据成员不向流中写入任何数据。记住,对象流不序列化static或transient。我们的类要用writeObject()与readObject()方法以处理这些数据成员。使用writeObject()与readObject()方法时,还要注意按写入的顺序读取这些数据成员。 

关于如何使用定制序列化的部分代码如下: 


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

1//重写writeObject()方法以便处理transient的成员。 

2public void writeObject(ObjectOutputStream outputStream)  throws  IOException{ 

3.   outputStream.defaultWriteObject();//使定制的writeObject()方法可以 

4.             利用自动序列化中内置的逻辑。 

5.   outputStream.writeObject(oSocket.getInetAddress()); 

6.   outputStream.writeInt(oSocket.getPort()); 

7. } 

8//重写readObject()方法以便接收transient的成员。 

9private void readObject(ObjectInputStream inputStream) throws 

            IOException,ClassNotFoundException{ 

10.   inputStream.defaultReadObject();//defaultReadObject()补充自动序列化 

11.    InetAddress oAddress=(InetAddress)inputStream.readObject(); 

12.    int iPort =inputStream.readInt(); 

13.   oSocket = new  Socket(oAddress,iPort); 

14.   iID=getID(); 

15.   dtToday =new  Date(); 

16. }

完全定制序列化过程: 

如果一个类要完全负责自己的序列化,则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现Externalizable时,头写入对象流中,然后类完全负责序列化和恢复数据成员,除了头以外,根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public,恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息,则要格外小心。这包括使用安全套接或加密整个字节流。到此为至,我们学习了序列化的基础部分知识。关于序 

列化的高级教程,以后再述。 

特别说明:尊重作者的劳动成果,转载请注明出处哦~~~http://blog.yemou.net/article/query/info/tytfjhfascvhzxcytp19

时间: 2016-05-19

Java对象序列化的相关文章

Ajax 的 Java 对象序列化

ajax|对象 如果您正在使用异步 JavaScript 和 XML(Ajax)进行 Java Web 开发,那么您最关心的问题可能就是把数据从服务器传递给客户机.在面向 Java 开发人员的 Ajax 系列的文章中,Philip McCarthy 介绍了 Java 对象序列化的五种方式,并提供了选择最适合应用程序的数据格式和技术所需要的全部信息.本文将侧重于许多 Java Web 开发人员最关心的问题:为客户机生成数据. 多数 Java 开发人员已经把模型-视图-控制器(MVC)模式应用在他们

Ajax 的 Java 对象序列化(1)

ajax|对象 如果您正在使用异步 JavaScript 和 XML(Ajax)进行 Java Web 开发,那么您最关心的问题可能就是把数据从服务器传递给客户机. 在面向 Java 开发人员的 Ajax 系列的文章中,Philip McCarthy 介绍了 Java 对象序列化的五种方式,并提供了选择最适合应用程序的数据格式和技术所需要的全部信息.本文将侧重于许多 Java Web 开发人员最关心的问题:为客户机生成数据. 多数 Java 开发人员已经把模型-视图-控制器(MVC)模式应用在他

java对象序列化学习笔记

java对象|笔记 目前网络上关于对象序列化的文章不少,但是我发现详细叙述用法和原理的文章太少.本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家.希望能为整个java社区的繁荣做一点事情.    序列化的过程就是对象写入字节流和从字节流中读取对象.将对象状态转换成字节流之后,可以用java.io包中的各种字节流类将其保存到文件中,管道到另一线程中或通过网络连接将对象数据发送到另一主机.对象序列化功能非常简单.强大,在RMI.Socket.JMS.EJB都有应用.对象序列化问题在网

关于Java对象序列化您不知道的5件事

数年前,当和一个软件团队一起用 Java 语言编写一个应用程序时,我体会 到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处. 大约一年前,一个负责管理应用程序所有用户设置的开发人员,决定将用户 设置存储在一个 Hashtable 中,然后将这个 Hashtable 序列化到磁盘,以便持 久化.当用户更改设置时,便重新将 Hashtable 写到磁盘. 这是一个优雅的.开放式的设置系统,但是,当团队决定从 Hashtable 迁移 到 Java Collections 库中的

Java对象序列化使用基础

所谓对象序列化就是将对象的状态转换成字节流,以后可以通过这些值再生成相同状态的对象.这个过程也可以通过网络实现,可以先在Windows机器上创建一个对象,对其序列化,然后通过网络发给一台Unix机器,然后在那里准确无误地重新"装配".像RMI.Socket.JMS.EJB它们中的一种,彼此为什么能够传递Java对象,当然都是对象序列化机制的功劳. Java对象序列化机制一般来讲有两种用途: Java的JavaBeans: Bean的状态信息通常是在设计时配置的,Bean的状态信息必须被

Java对象序列化/反序列化的注意事项(转)

Java对象序列化     对于一个存在Java虚拟机中的对象来说,其内部的状态只是保存在内存中.JVM退出之后,内存资源也就被释放,Java对象的内部状态也就丢失了.而在很多情况下,对象内部状态是需要被持久化的,将运行中的对象状态保存下来(最直接的方式就是保存到文件系统中),在需要的时候可以还原,即使是在Java虚拟机退出的情况下.     对象序列化机制是Java内建的一种对象持久化方式,可以很容易实现在JVM中的活动对象与字节数组(流)之间进行转换,使用得Java对象可以被存储,可以被网络

Ajax 的 Java 对象序列化(2)

ajax|对象 Fujak Superpix72 Camera 7.2 Megapixel digital camera featuring six shooting modes and 3x optical zoom. Silver.$299.99自行序列化的不足 有趣的是,清单 3 中的代码展示了让 JavaBean 把自己序列化为 XML 的一个主要不足.假设要用这个文档表示顾客的订单历史视图.在这种情况下,不太可能要显示每个历史订单中每个商品的完整说明,或者告诉顾客他或她自己的姓名.但是

面向Java开发人员的Ajax:Java对象序列化(1)

ajax|java对象 本文我们讨论 Ajax 开发的基础知识,但是将侧重于许多 Java Web 开发人员最关心的问题:为客户机生成数据. 多数 Java 开发人员已经把模型-视图-控制器(MVC)模式应用在他们的 Web 应用程序上.在传统的 Web 应用程序中,视图组件由 JSP 或者其他表示技术(例如 Velocity 模板)构成. 这些表示组件动态地生成全新的 HTML 页面,替代用户以前正在查看的页面,从而更新用户界面.但是,在 Java Web 应用程序使用 Ajax UI 的情况

JAVA对象序列化保存为XML文件的工具类

java对象|xml   今天看了看java.beans包,发现了两个好东西,XMLEncoder和XMLDecoder.发现自己以前把从XML存取对象真是太费力气啦.做了小工具类,以后可以用用了. package com.imct.util; import java.beans.XMLDecoder;import java.beans.XMLEncoder;import java.io.File;import java.io.FileInputStream;import java.io.Fil

面向Java开发人员的Ajax: Ajax的Java对象序列化

在这个系列的 第一篇文章 中,我介绍了 Ajax 的构造块: 如何用 JavaScript XMLHttpRequest 对象从 Web 页面向服务器发送异步请求. 如何用 Java servlet 处理和响应请求(向客户机返回 XML 文档). 如何在客户端用响应文档更新页面视图. 这一次,我将继续讨论 Ajax 开发的基础知识,但是将侧重于许多 Java Web 开发人员最关心的问题:为客户机生成数据. 多数 Java 开发人员已经把模型-视图-控制器(MVC)模式应用在他们的 Web 应用