浅谈序列化（Serializable）

在写这篇文章之前，当时正在看 Java 数据结构和集合框架的源码实现，正巧碰到了 ArrayList 源码中的两个私有方法：writeObject 和 readObject

/**
 * Save the state of the <tt>ArrayList</tt> instance to a stream (that is, serialize it).
 * readObject的代码就不贴出来了
 */
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

正是这两个方法引起了我的思考：为什么这两个方法是私有的，但是在类中没有被调用，到底是在什么地方使用的呢？那么接下来让我们进入正题。

一、什么是序列化和反序列化？

Java 序列化就是将对象以某种形式保持，比如存在硬盘、网络传输等；反序列化是这样的一个逆过程，将某种形式的数据转化成对象，这是一个抽象的概念。注：static 和 transient 修饰的属性不会被序列化。
简单举例：在 Java 中，现存在一个 Box 类，我需要把这个类的属性保存到文件中并且存在我的计算机硬盘中；这个时候我们的这个 Box 类就需要实现java.io.Serializable这个接口，进而使用输出流把类的属性保存到文件中。反之，从这个文件中获取这个对象的信息就是反序列化。
代码如下：

public class Box implements Serializable {
    private static final long serialVersionUID = -3450064362986273896L;
    
    private int width;
    private int height; 
    
    public int getWidth() {
        return width;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
   
    public static void main(String[] args) {
        Box myBox=new Box();
        myBox.setWidth(50);
        myBox.setHeight(30);
        try {
            // 序列化过程
            FileOutputStream fs=new FileOutputStream("F:\\foo.ser");
            ObjectOutputStream os=new ObjectOutputStream(fs);
            os.writeObject(myBox);
            os.close();
            // 反序列化过程
            FileInputStream fi=new FileInputStream("F:\\foo.ser");
            ObjectInputStream oi=new ObjectInputStream(fi);
            Box box=(Box)oi.readObject();
            oi.close();
            System.out.println(box.height+","+box.width);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、为什么要序列化？

• 作为一种持久化机制
  如果使用的是FileOutputStream流的方式，则数据将被自动地写入文件中。
• 作为一种复制机制
  如果使用的是ByteArrayOutputStream流的方式，数据将写入内存中的字节数组中。该字节数组可以用来创建初始对象的副本。
• 作为一种通信机制
  如果是使用套接字（Socket）流的方式，则数据自动地通过网络连接传输一另一个端点，并由这个端点上的程序来决定做什么。

三、序列化过程？

类通过实现 java.io.Serializable 接口开启序列化功能，这个接口没有任何方法需要实现。要序列化一个对象，就必然会将输入 / 输出流联系起来，通过输出流将对象的状态保存下来，通过输入流将对象的状态获取回来。
在序列化和反序列化的过程中，如果有需要特殊实现的类，则需要使用以下准确的签名来自定义该过程：

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException

1. 写入

• 首先创建一个 OutputStream 输出流；
• 然后创建一个 ObjectOutputStream 输出流，并传入 OutputStream 输出流对象；
• 最后调用 ObjectOutputStream 对象的 writeObject() 方法将对象状态信息写入 OutputStream。

2. 读取

• 首先创建一个 InputStream 输入流；
• 然后创建一个 ObjectInputStream 输入流，并传入 InputStream 输入流对象；
• 最后调用 ObjectInputStream 对象的 readObject() 方法从 InputStream 中读取对象状态信息。

注：在需要序列化或者反序列化的对象中自定义实现了 writeObject() 和 readObject() 方法，则在上述写入和读取过程的第三步调用方法时会调取自定义实现的方法（ ObjectOutputStream 会调用这个类的 writeObject 方法进行序列化， ObjectInputStream 会调用相应的 readObject 方法进行反序列化），这是由于反射机制原理。

四、transient 关键字

我们知道，一个对象只要实现了 Seriallzable 接口，这个对象就可以被序列化，它的所有属性也会被序列化（这里说的所有也不严谨，只是为了提高语境），Java 的序列化过程让我们开发者使用起来很方便。
当然，在实际开发过程中并不是这样的，我们会遇到很多问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，比如：用户的密码，银行卡号等等这些敏感的数据我们不希望它被序列化保存在硬盘中，或者在网络中进行传输。虽然被破解的可能性不大，但是存在安全问题，这个时侯这些信息对应的变量就可以加上 transient 关键字。换言之，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。
总之，java 的 transient 关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字 transient ，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

问题

1. 为什么 java.util.ArrayList 中的 elementData 要被 transient 修饰呢？
   答：因为 ArrayList 底层数据结构是动态数组（涉及到扩容），其容量可能大于当前数组的元素个数，如果直接对 elementData 进行序列化，会浪费元素的空间。
   比如，现在实际有了 8 个元素，那么 elementData 数组的容量可能是 8x1.5=12，如果直接序列化 elementData 数组，那么就会浪费 4 个元素的空间，特别是当元素个数非常多时，这种浪费是非常不合算的。
   所以 ArrayList 的设计者将 elementData 设计为 transient ，然后在 writeObject 方法中手动将其序列化，并且只序列化了实际存储的那些元素，而不是整个数组。
2. 为什么 java.util.ArrayList 中的 elementData 被 transient 修饰还可以序列化呢？
   答：这个就是因为 ArrayList 自己实现了自定义的 writeObject 和 readObject 方法，虽然 elementData 不能被序列化，但是他的元素阔以，具体见源码。