理解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();
    }

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

1. 序列化其实是在保存对象的状态，所以static修饰的静态的域不会被保存，static修饰的对象是类的状态，即使在该对象中被修改过，依然不会被序列化保存。
2. 在序列化时，不仅会序列化对象本身，还会对该对象引用的其他对象也进行序列化，所以要求这些对象也是可序列对象。
3. 如果是一个子类实现了序列化接口，但是它继承的父类没有实现，那么父类不会被序列化，而是在子类被反序列化时，递归调用父类默认的无参构造函数。所以在子类中修改了父类引用的对象值，反序列后，该对象的值不会是修改后的，而是在父类的无参构造函数中赋予的值，如果没有赋值，则是初始化为默认值。而如果父类中没有无参构造函数，将会抛出异常：InvalidClassException
4. 序列化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<Integer> a=new ArrayList<Integer>();
        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的输出正确。

最后

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

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