java 对象 反序列化_对象的序列化和反序列化（转载＋原创）

本文主体内容转载自http://www.blogjava.net/amigoxie/archive/2007/09/16/145465.html，同时也根据自己的学习体会，参考多方面资料，对其加以补充

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。

－－－－－－－－－－－以下内容节选自《Thinking in java 3rd Edition》－－－－－－－－－－－－－

利用对象序列化可以实现“轻量级持久化”(lightweight persistence)。“持久化”意味着一个对象的生存周期并不取决于程序是否正在执行；它可以生存于程序的调用之间。通过将一个序列化对象写入磁盘，然后在重新调用时恢复该对象，就能够实现持久化的效果。之所以称其为“轻量级”，是因为不能用某种“persistent”(持久)关键字来简单地定义一个对象，并让系统自动维护其他细节问题(尽管将来有可能实现)。相反，对象必须在程序中显式地序列化和重组。如果需要一个更严格的持久化机制，可以考虑使用Java数据对象(JDO)或者像Hibernate之类的工具

对象序列化的概念加入到语言中是为了提供对两种主要特性的支持：

·Java的“远程方法调用”(RMI，Remote Method Invocation)使存活于其他计算机上的对象使用起来就像是存活于本机上一样。当向远程对象发送消息时，需要通过对象序列化来传输参数和返回值。

·对Java Beans来说对象序列化也是必需的。使用一个Bean时，一般情况下是在设计阶段对它的状态信息进行配置。这种状态信息必须保存下来，并在程序启动以后，进行恢复；具体工作由对象序列化完成。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

对象的序列化主要有两种用途：

1) 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2)在网络上传送对象的字节序列。

一．JDK类库中的序列化APIjava.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

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

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。

对象序列化包括如下步骤：

1) 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2) 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1) 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2) 通过对象输入流的readObject()方法读取对象。

下面让我们来看一个对应的例子，类的内容如下：

importjava.io.*;

importjava.util.Date;

/** *//**

 * 对象的序列化和反序列化测试类.     

 *@authorAmigoXie

 *@version1.0 

 * Creation date: 2007-9-15 - 下午21:45:48

*/

publicclassObjectSaver{

/** *//**

        *@paramargs

        *@authorAmigoXie

        * Creation date: 2007-9-15 - 下午21:45:37

*/

publicstaticvoidmain(String[] args)throwsException{

              ObjectOutputStream out=newObjectOutputStream

                     (newFileOutputStream("D:""objectFile.obj"));

//序列化对象              Customer customer=newCustomer("阿蜜果",24);

              out.writeObject("你好!");

              out.writeObject(newDate());

              out.writeObject(customer);

              out.writeInt(123);//写入基本类型数据              out.close();

//反序列化对象              ObjectInputStream in=newObjectInputStream

                     (newFileInputStream("D:""objectFile.obj"));

              System.out.println("obj1="+(String) in.readObject());

              System.out.println("obj2="+(Date) in.readObject());

              Customer obj3=(Customer) in.readObject();

              System.out.println("obj3="+obj3);

intobj4=in.readInt();

              System.out.println("obj4="+obj4);

              in.close();

       }

}

classCustomerimplementsSerializable{

privateString name;

privateintage;

publicCustomer(String name,intage){

this.name=name;

this.age=age;

       }

publicString toString(){

return"name="+name+", age="+age;

       }

}

输出结果如下：

obj1=你好!

obj2=Sat Sep 15 22:02:21 CST 2007

obj3=name=阿蜜果, age=24

obj4=123

因此例比较简单，在此不再详述。

二实现Serializable接口

ObjectOutputStream只能对Serializable接口的类的对象进行序列化。默认情况下，ObjectOutputStream按照默认方式序列化，这种序列化方式仅仅对对象的非transient的实例变量进行序列化，而不会序列化对象的transient的实例变量，也不会序列化静态变量。当ObjectIntputStream按照默认方式反序列化时，具有如下特点：

1)如果在内存中对象所属的类还没有被加载，那么会先加载并初始化这个类。如果在classpath中不存在相应的类文件，那么会抛出ClassNotFoundException；

2)在反序列化时不会调用类的任何构造方法(注意与下面Externalizable接口的区别)。

如果用户希望控制类的序列化方式，可以在可序列化类中提供以下形式的writeObject()和readObject()方法。

private void writeObject(java.io.ObjectOutputStream out) throws IOException

private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

需要注意的地方是：上面两个方法并不是Serializable接口定义的，Serializable只是一个标记接口，并没有任何内容。而且这两个方法都是private的，但却并不是被定义这两个方法的类本身所调用——当ObjectOutputStream对一个Customer对象进行序列化时，如果该对象具有writeObject()方法，那么就会执行这一方法，否则就按默认方式序列化。在该对象的writeObjectt()方法中，可以先调用ObjectOutputStream的defaultWriteObject()方法，使得对象输出流先执行默认的序列化操作。同理可得出反序列化的情况，不过这次是defaultReadObject()方法。

有些对象中包含一些敏感信息，这些信息不宜对外公开。如果按照默认方式对它们序列化，那么它们的序列化数据在网络上传输时，可能会被不法份子窃取。对于这类信息，可以对它们进行加密后再序列化，在反序列化时则需要解密，再恢复为原来的信息——这是transient关键字的第一个用途，屏蔽敏感信息。

transient的第二个功能是在用途时，将某些无需序列化的成员变量设为transient类型，将节省空间和时间，提高序列化的性能。

transient的第三个用途是如果类的内部有某个非序列化的对象引用，可以将其标记为transient来避免抛出NotSerializableException异常

默认的序列化方式会序列化整个对象图，这需要递归遍历对象图。如果对象图很复杂，递归遍历操作需要消耗很多的空间和时间，它的内部数据结构为双向列表。

注意在递归遍历过程中，对同一对象的引用如果出现多次，序列化过程并不会重复写入多个，具体的做法如下：

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

·当要保存一个对象时，先检查该对象是否已经被保存了

·如果以前保存过，只需写入“与已经保存的具有序列号x的对象相同”标记；否则，保存它的所有数据

当需要读回对象时，将上述过程简单地逆转即可。

三实现Externalizable接口

Externalizable接口继承自Serializable接口，如果一个类实现了Externalizable接口，那么将完全由这个类控制自身的序列化行为。Externalizable接口声明了两个方法：

public void writeExternal(ObjectOutput out) throws IOException

public void readExternal(ObjectInput in) throws IOException , ClassNotFoundException

前者负责序列化操作，后者负责反序列化操作。

在对实现了Externalizable接口的类的对象进行反序列化时，会先调用类的不带参数的构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常。类实现externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。

这里要注意了：声明类实现Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。

四    可序列化类的不同版本的序列化兼容性

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：    private static final long serialVersionUID;

以上serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。

类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。显式地定义serialVersionUID有两种用途：

1)在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2)在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

五    利用序列化来“克隆”对象

要知道，序列化是对对象的一个“深拷贝”，为此我们完全可以用序列化来克隆一个对象(如果支持的话)。

要克隆序列化对象，简单地将该对象序列化到输出流中去，然后再读取回来。结果就是一个对已经存在的对象进行了深拷贝的新对象。我们不需要将该对象写入文件中——可以使用ByteArrayOutputStream将数据保存在字节数组中。

但是，这种方法尽管很聪明，但是比创建一个新的对象，然后拷贝或克隆数据字段的克隆方法要慢许多。

例：

/** *//**  A class whose clone method uses serialization

*/

classSerialCloneableimplementsCloneable, Serializable

{

try{

//save the object to a byte arrayByteArrayOutputStream bout=newByteArrayOutputStream();

        ObjectOutputStream out=newObjectOutputStream(bout);

        out.writeObject(this);

        out.close();

//read a clone of the object from the byte arrayByteArrayInputStream bin=newByteArrayInputStream(bout.toByteArray);

        ObjectInputStream in=newObjectInputStream(bin);

        Object ret=in.readObject();

        in.close();

        ret.close();

    }

catch(Exception e){

returnnull;

    }}

/** *//**  Now the class Employee is able to clone itself using serialization

*/

classEmployeeextendsSerialCloneable{

//}

六    Preferences

JDK 1.4引入了Preferences API，它比对象序列化更接近于持久化，因为它可以自动存储和读取信息。不过，它只能用于小的受限的集合——我们只能存储原始类型和字符串，并且每个字符串的存储长度不能超过8K。正如其名，Preferences API用于存储和读取用户的Preferences以及程序配置项的设置。

Preferences是一个键值集合(类似映射)，存储在一个结点层次结构中。

七    有关序列化的一些最佳实践(转自http://java.ccidnet.com/art/3737/20040111/469787_1.html)

1、实现Serializable回导致发布的API难以更改，并且使得package-private和private

这两个本来封装的较好的咚咚也不能得到保障了

2、Serializable会为每个类生成一个序列号，生成依据是类名、类实现的接口名、

public和protected方法，所以只要你一不小心改了一个已经publish的API，并且没有自

己定义一个long类型的叫做serialVersionUID的field，哪怕只是添加一个getXX，就会

让你读原来的序列化到文件中的东西读不出来(不知道为什么要把方法名算进去？)

3、不用构造函数用Serializable就可以构造对象，看起来不大合理，这被称为

extralinguistic mechanism，所以当实现Serializable时应该注意维持构造函数中所维

持的那些不变状态

4、增加了发布新版本的类时的测试负担

5、1.4版本后，JavaBeans的持久化采用基于XML的机制，不再需要Serializable

6、设计用来被继承的类时，尽量不实现Serializable，用来被继承的interface也不要

继承Serializable。但是如果父类不实现Serializable接口，子类很难实现它，特别是

对于父类没有可以访问的不含参数的构造函数的时候。所以，一旦你决定不实现

Serializable接口并且类被用来继承的时候记得提供一个无参数的构造函数

7、不管你选择什么序列化形式，声明一个显式的UID：

private static final long serialVersionUID = randomLongValue;

8、不需要序列化的东西使用transient注掉它吧，别什么都留着

9、writeObject/readObject重载以完成更好的序列化

readResolve 与 writeReplace重载以完成更好的维护invariant controllers

八        总结

·要想序列化，需要声明实现Serializable接口(Exeternalizable一会再说)

·如果有些东西想藏起来，用transient标识

·如果想自己处理transient或static成员，自己定义readObject()和writeObject()

·如果完全想自己处理，实现Exeternalizable接口

posted on 2008-10-29 21:19 This is Wing 阅读(1046) 评论(0)  编辑  收藏 所属分类: Java基础