Java 序列化的问题

【本文为转载，以做备忘，对其中的例子做了修改，原文地址：http://liu-hliang.iteye.com/blog/748356，感谢原作者】

 

   把Java对象转换为字节序列的过程称为对象的序列化。
   把字节序列恢复为Java对象的过程称为对象的反序列化。
   ava中引入序列化机制主要是为了支持两种重要技术：RMI和JavaBean技术。
   

    对象的序列化主要有两种用途：
　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
　　2） 在网络上传送对象的字节序列。
   只有实现了Serializable和Externalizable接口的类的对象才能被序列化。
      1）Serializable接口可使类中的所有成员变量自动被序列化（transient和static修饰的变量除外），默认的
           序列化方式会序列化整个对象图，这需要递归遍历对象图。如果对象图很复杂，递归遍历操作需要消耗很多
           的空间和时间，它的内部数据结构为双向列表。在应用时，如果对某些成员变量都改为transient类型，将
           节省空间和时间，提高序列化的性能。
      2）Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化
           的行为，即Externalizable对象默认情况下不保存任何它的字段，而仅实现Serializable接口的类可以
           采用默认的序列化方式 。
   那我们如何对一个Serializable对象的序列化和反序列化行为进行控制呢？
      1）加transient修饰符，这样改变量就不会被序列化了
      2）添加（不是“实现”和“重载” ）writeObject和readObject方法： private void writeObject(ObjectOutputStream stream) throws IOException; private void readObject(ObjectOutputStream stream) throws IOException;

     这样一旦对象被序列化或者被反序列化，就会自动分别调用这两个方法，而不会调用默认的序列化和反序列化方法。（这一点确实感觉有点奇怪，或者叫混乱！）
    当 ObjectOutputStream对一个Serializable对象进行序列化时，如果该对象具有writeObject()方法，那么就会执行这一方法，否则就按默认方式序列化。在该对象的writeObjectt()方法中，可以先调用ObjectOutputStream的 defaultWriteObject()方法，使得对象输出流先执行默认的序列化操作。同理可得出反序列化的情况，不过这次是 defaultReadObject()方法。

# 对Serializable对象反序列化时，并不会调用任何构造函数 ，因此Serializable类无需默认构造函数，但是当Serializable类的父类没有实现Serializable接口时，反序列化过程会调用父类的默认构造函数，因此该父类必需有默认构造函数，否则会抛异常。

 

 

# 对Externalizable对象反序列化时，会先调用类的不带参数的构造方法 ，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常，因此Externalizable对象必须有默认构造函数，而且必需是public的。

# 对象序列化包括如下步骤：
　　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
　　2） 通过对象输出流的writeObject()方法写对象。
# 对象反序列化的步骤如下：
　　1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
　　2） 通过对象输入流的readObject()方法读取对象。
下面是个简单的例子：

 

class Animal {
    Animal() {
        System.out.print("a");
    }
}

class Dog extends Animal implements Serializable {
    private static final long serialVersionUID = 1L;
    Dog() {
        System.out.print("d");
    }
}
class Beagle extends Dog {
    private static final long serialVersionUID = 1L;
}


public class Test {
    public static void main(String[] args) {
        Beagle bg = new Beagle();
        try {
            //序列化
            FileOutputStream fos = new FileOutputStream("myobj.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(bg);
            oos.flush();
            oos.close();

            //反序列化
            FileInputStream fis = new FileInputStream("myobj.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            bg = (Beagle)ois.readObject();
            ois.close();

            System.out.println(bg.master.name);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        } catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}

    输出：ada

 

 

 

    关于serialVersionUID：
    在 Loong（我们公司自己开发的基于OSGI的网络应用服务器平台）中集成Glassfish 的数据源时遇到了序列化的问题：在Glassfish中序列化的连接池对象，在Loong里面反序列化时总是不成功！后来查了相关资料，原来是连接池类出了问题：只实现了Serializable接口，没有指定具体的serialVersionUID。
    凡是实现Serializable接口的类都应当有一个表示序列化版本标识符的静态变量：
private static final long serialVersionUID;

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

　 类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提高哦啊serialVersionUID的独立性和确定性，强烈建议 在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。
    显式地定义serialVersionUID有两种用途：
　　1） 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；
　　2） 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。
# 利用java的序列化和反序列化机制可以实现对任何可Serializable的对象的深度复制
    上面的例子里，现将MyObject对象序列化到硬盘文件 c:/objectFile.data，然后反序列化之，这样可以实现深度复制，但是由于操作硬盘，所以当该操作比较频繁时会严重影响系统性能，上面是用文件流方式的实现，我们可以用字节流方式来高效的实现深度复制：

 

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;


public class Test{
    public static void main(String[] args) throws Exception {
        //序列化对象
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream( bos);
        MyObject obj1= new MyObject("John", 24);
        out.writeObject("hello world！");
        out.writeObject(new Date());
        out.writeObject(obj1);
        out.writeInt(54);
        out.close();

        //反序列化对象
        ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream(bos.toByteArray()));
        System.out.println("obj1=" + (String) in.readObject());
        System.out.println("obj2=" + (Date) in.readObject());
        MyObject obj3 = (MyObject) in.readObject();
        System.out.println("obj3=" + obj3);
        int obj4 = in.readInt();
        System.out.println("obj4=" + obj4);
        in.close();
      }
 }
//自定义可序列化类
class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    public MyObject(String name, int age) {
        this.name = name; this.age = age;
    }
    public String toString() {
        return "name=" + name + ", age=" + age;
    }
}