本文主体内容转载自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 array
ByteArrayOutputStream bout=newByteArrayOutputStream();
ObjectOutputStream out=newObjectOutputStream(bout);
out.writeObject(this);
out.close();
//read a clone of the object from the byte array
ByteArrayInputStream 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基础