Java基础21-读懂Java序列化和反序列化（二）

    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        private static final long serialVersionUID = 8683452581122892189L;
        transient Object[] elementData; // non-private to simplify nested class access
        private int size;
    }复制代码

    public class ArrayList的序列化 {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            ArrayList list = new ArrayList();
            list.add("a");
            list.add("b");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("arr"));
            objectOutputStream.writeObject(list);
            objectOutputStream.close();
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("arr"));
            ArrayList list1 = (ArrayList) objectInputStream.readObject();
            objectInputStream.close();
            System.out.println(Arrays.toString(list.toArray()));
            //序列化成功，里面的元素保持不变。
        }复制代码

    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            elementData = EMPTY_ELEMENTDATA;复制代码

            // Read in size, and any hidden stuff
            s.defaultReadObject();复制代码

            // Read in capacity
            s.readInt(); // ignored复制代码

            if (size > 0) {
                // be like clone(), allocate array based upon size not capacity
                ensureCapacityInternal(size);复制代码

                Object[] a = elementData;
                // Read in all elements in the proper order.
                for (int i=0; i<size; i++) {
                    a[i] = s.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();
            }
        }复制代码

    why transient
    ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient。复制代码

    why writeObject and readObject
    前面说过，为了防止一个包含大量空对象的数组被序列化，为了优化存储，所以，ArrayList使用transient来声明elementData。 但是，作为一个集合，在序列化过程中还必须保证其中的元素可以被持久化下来，所以，通过重写writeObject 和 readObject方法的方式把其中的元素保留下来。复制代码

    writeObject方法把elementData数组中的元素遍历的保存到输出流（ObjectOutputStream）中。复制代码

    readObject方法从输入流（ObjectInputStream）中读出对象并保存赋值到elementData数组中。
    
复制代码

    void invokeWriteObject(Object obj, ObjectOutputStream out)
            throws IOException, UnsupportedOperationException
        {
            if (writeObjectMethod != null) {
                try {
                    writeObjectMethod.invoke(obj, new Object[]{ out });
                } catch (InvocationTargetException ex) {
                    Throwable th = ex.getTargetException();
                    if (th instanceof IOException) {
                        throw (IOException) th;
                    } else {
                        throwMiscException(th);
                    }
                } catch (IllegalAccessException ex) {
                    // should not occur, as access checks have been suppressed
                    throw new InternalError(ex);
                }
            } else {
                throw new UnsupportedOperationException();
            }
        }
其中writeObjectMethod.invoke(obj, new Object[]{ out });是关键，通过反射的方式调用writeObjectMethod方法。官方是这么解释这个writeObjectMethod的：复制代码

    如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的?复制代码

    答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用。
    复制代码

    Serializable接口的定义：复制代码

    public interface Serializable {
    }
    读者可以尝试把code 1中的继承Serializable的代码去掉，再执行code 2，会抛出java.io.NotSerializableException。复制代码

    writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject复制代码

    if (obj instanceof String) {
                    writeString((String) obj, unshared);
                } else if (cl.isArray()) {
                    writeArray(obj, desc, unshared);
                } else if (obj instanceof Enum) {
                    writeEnum((Enum<?>) obj, desc, unshared);
                } else if (obj instanceof Serializable) {
                    writeOrdinaryObject(obj, desc, unshared);
                } else {
                    if (extendedDebugInfo) {
                        throw new NotSerializableException(
                            cl.getName() + "\n" + debugInfoStack.toString());
                    } else {
                        throw new NotSerializableException(cl.getName());
                    }
                }
在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果不是则直接抛出NotSerializableException。
复制代码