java序列化理解,理解Java序列化

什么是序列化

Java序列化其实是由Java序列接口提供框架将对象转换成字节序列，而反序列则是将字节序列重新转换成对象的过程。

序列化本身其实是一个“持久化”的过程，通常情况下Java的对象都存活在内存中，而序列化后可以以字节序列的形式保存在物理存储设备上。

如何实现序列化呢

通常情况下一个类只要实现了Serializable接口，那么它的对象就可以被序列化，生成默认的序列化格式。例如对son 类实现序列化的定义声明：

public class son implements Serializable

下面是son类，只有一个变量，在默认构造参数中被赋值，并且输出一句类名到控制台上：

public class son implements Serializable{

int b;

public son(){

b=2222;

System.out.println("son");

}

}

再测试的主函数中，我们创建要保存的文件，打开文件输入/输出流，然后用对象输入/输出流把它包装起来，接下来就可以通过调用writeObject/readObject来序列化和反序列化对象：

public static void main(String[] args) throws Exception {

File relative= new File("demo/");

if(!relative.exists()){

relative.mkdirs();

}

File file=new File(relative,"serial.out");

if(!file.exists()){

try {

file.createNewFile();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

// son son1=new son();

// ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream(file));

// oos.writeObject(son1);

// oos.flush();

// oos.close();

// System.out.println("done");

ObjectInputStream ois =new ObjectInputStream(new FileInputStream(file));

son son2=(son)ois.readObject();

System.out.println(son2);

System.out.println(son2.b);

ois.close();

}

上面就是简单的序列化，但是序列化本身还有一些头疼的事情。有这样几点：

序列化其实是在保存对象的状态，所以static修饰的静态的域不会被保存，static修饰的对象是类的状态，即使在该对象中被修改过，依然不会被序列化保存。

在序列化时，不仅会序列化对象本身，还会对该对象引用的其他对象也进行序列化，所以要求这些对象也是可序列对象。

如果是一个子类实现了序列化接口，但是它继承的父类没有实现，那么父类不会被序列化，而是在子类被反序列化时，递归调用父类默认的无参构造函数。所以在子类中修改了父类引用的对象值，反序列后，该对象的值不会是修改后的，而是在父类的无参构造函数中赋予的值，如果没有赋值，则是初始化为默认值。而如果父类中没有无参构造函数，将会抛出异常：InvalidClassException

序列化ID问题。在进行反序列化时，会对字节流中的serialVersionUID与本地的实体类的serialVersionUID进行比较，如果一致才能反序列化成功，否则会报错。而serialVersionUID默认情况下是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，如果不想根据编译来划分版本，就可以显示定义一个serialVersionUID来兼容以前编译的版本:

private static final long serialVersionUID = 1L;

针对第三个问题这里我们再看一个父类没有实现序列化的情况：

下面是parent类：

public class parent{

int a;

public parent(){

System.out.println("parent");

a=111;

}

}

对son类也稍作修改：

public class son extends parent implements Serializable{

int b;

transient int tmp=100;

public son(){

a=222;

b=2222;

System.out.println("son");

}

}

父类很简单，不实现Serializable接口，有一个变量a,在无参构造函数中赋值，并且输出类名。

在son类中稍作修改，对父类的变量a赋新值。

在son类中还添加了一个tmp变量，被transient修饰，所有被transient修饰的对象都不会被默认序列化，只能自己定义序列化的细节。(再以后的文章中讨论)

main函数，多添加两句打印输出语句：

public class Main {

public static void main(String[] args) throws Exception {

ArrayList a=new ArrayList();

File relative= new File("demo/");

if(!relative.exists()){

relative.mkdirs();

}

File file=new File(relative,"serial.txt");

if(!file.exists()){

try {

file.createNewFile();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

//

// son son1=new son();

// ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream(file));

// oos.writeObject(son1);

// oos.flush();

// oos.close();

// System.out.println("done");

ObjectInputStream ois =new ObjectInputStream(new FileInputStream(file));

son son2=(son)ois.readObject();

System.out.println(son2); //打印对象名

System.out.println(son2.a); //打印反序列后引用父类变量的值

System.out.println(son2.b);

ois.close();

}

}

测试结果

我们看在第一次序列化写入文件的情况下控制台的输出：

parent

son

done

在实例化son类的过程中先递归调用了父类无参构造函数，然后才是son类中的构造函数，在最后序列化成功后输出done，程序结束。

下面是反序列化时的输出：

parent

son@5c647e05

111

2222

可以看到反序列的过程中首先调用了父类的无参构造函数，接着打印了反序列后的对象名(同程序中如果直接序列化然后立马反序列，可以看到两个对象哈希值是不同的，这里没有比较)，然后输出了父类中的变量a,可以看到值为111，不是在son的构造函数中赋值的222，证明对父类范围内的对象做修改没有用。最后变量b的输出正确。

最后

可以看到，序列化和继承之间有一些矛盾，同时序列化将类中私有域也序列化输出，破坏了类的封闭性。所以设计类的时候尽量不实现序列化，同时如果该类会被广泛继承，而继承后的子类可能要序列化，那么该类要提供一个无参构造函数，并且在该构造函数中给对象赋值。

并且，默认序列化并不能满足所有场景和需求，后面的文章我们会认识一下定制序列化的方式。