Java对象序列化的使用和定制

序列化的概念及使用场合

序列化就是把对象转化为字节序列并持久化保存，可以保存在内存中、磁盘文件系统，甚至通过网络传递，并能够在以后将这个字节序列完全恢复为原来的对象。

对象序列化的概念引入Java是为了支持两种主要特性：

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

二是对于Java Beans来说，对象的序列化也是必须的。使用一个Bean时，一般情况下是在设计阶段对它的状态信息进行配置，而这种状态信息必须保存下来，并在程序启动时进行后期恢复。

序列化操作步骤：

要使得一个对象可以被序列化，首先要实现实现接口Serializable(该接口仅是一个标记接口，不包括任何方法)；

使用ObjectOutputStream包装一个OutputStream对象，在调用ObjectOutputStream的writeObject()来序列化；

使用ObjectInputStream包装一个InputStream对象，在调用ObjectInputStream的readObject()来反序列化；

因为序列化最终是字节序列，所以必须字节流，而不能使用字符流(关于字节流和字符流请参考这里)。


序列化Demo

public class App
{
public static void main( String[] args ) throws Exception, IOException
{
User user=new User();
user.setName("net.oseye");
user.setAge(18);;

//序列化
//使用ObjectOutputStream包装OutputStream
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("out.txt"));
out.writeObject("下面是序列化的User:");
out.writeObject(user);
out.close();

//反序列化
//
ObjectInputStream in=new ObjectInputStream(new FileInputStream("out.txt"));
System.out.println(in.readObject());
//查看反序列化后的对象类型，方便反射
Object obj=in.readObject();
System.out.println(obj.getClass());

user=(User)obj;
System.out.println(user);
System.out.println("user的name:"+user.getName());
System.out.println("user的age:"+user.getAge());
in.close();
}
}

//实现标记接口Serializable
@SuppressWarnings("serial")
class User implements Serializable{
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}

private int age;
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
}

输出



如果我们不想序列化某个字段可以使用transient(瞬时)关键字来修饰字段，如：

public class App
{
public static void main( String[] args ) throws Exception, IOException
{
//如前面示例代码....
}
}

//实现标记接口Serializable
class User implements Serializable{
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}

private transient int age;
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
}

这样就不会序列化age字段了。

使用Externalizable定制序列化

使用transient关键字可以简单定制序列化，但如果更复杂的定制可以使用Externalizable接口代替标记接口Serializable，因为Externalizable有序列化和反序列化的方法

public class App
{
public static void main( String[] args ) throws Exception, IOException
{
//如前面示例代码....
}
}

//实现标记接口Externalizable
class User implements Externalizable{
public User(){}
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}

private transient int age;
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}

public void writeExternal(ObjectOutput out) throws IOException {
this.name="已经被序列化了："+this.name;
out.writeObject(this.name);
}
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
this.name=(String)in.readObject();
}
}

输出



问题：我发现使用Externalizable接口实现的类必须显示声明构造函数，如上例不显示声明

public User(){}

将会报异常：


至于原因有待查明....，如果你知道也请告诉我，谢谢。

使用Serializable定制序列化

其实如果你不是特别坚持使用Externalizable接口的话，使用Serializable接口也可以实现定制，但却使用迷惑，因为需要添加

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException;

这两个方法，如果你细心你会发现和Externalizable接口的中的两个方法很像。迷惑的地方是Serializable是标记接口，而我们感觉无端增加了两个私有方法！！

一旦在接口Serializable的实现类中添加了上面两个方法，序列化和反序列化就会自动调用：

//实现标记接口Serializable
@SuppressWarnings("serial")
class User implements Serializable{
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}

private int age;
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}

private void writeObject(ObjectOutputStream out) throws IOException {
this.name="已经被序列化了："+this.name;
out.writeObject(this.name);
}
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
this.name=(String)in.readObject();
}
}