Java序列化与反序列化详解

Java Socket编程实例:[url]http://donald-draper.iteye.com/blog/2356695[/url]
java Socket读写缓存区Writer和Reader：[url]http://donald-draper.iteye.com/blog/2356885[/url]
Java NIO ByteBuffer详解：[url]http://donald-draper.iteye.com/blog/2357084[/url]
Java序列化与反序列化实例分析：[url]http://donald-draper.iteye.com/blog/2357515[/url]
在上面一篇Java序列化与反序列化教程，我们通过实例，分析了Java序列化与反序列化，今天我们来更深入的去看一下ObjectOutputStream和ObjectInputStream是如何序列化与反序列化对象和原始类型的；
1.序列化

ObjectOutputStream objectOutputStream = null;
try {
	objectOutputStream = new ObjectOutputStream(outFile);
} catch (IOException e) {
	e.printStackTrace();
}
PersonX person = new PersonX("donald", 27, "man");
try {
	objectOutputStream.writeObject(person);
	objectOutputStream.writeInt(4);
	objectOutputStream.writeUTF("it is a man");
	objectOutputStream.close();
} catch (IOException e) {
	e.printStackTrace();
}

序列化的关键在这几句

objectOutputStream = new ObjectOutputStream(outFile);
objectOutputStream.writeObject(person);
objectOutputStream.writeInt(4);
objectOutputStream.writeUTF("it is a man");

我们一句一句的分析，先看构造ObjectOutputStream

public class ObjectOutputStream
    extends OutputStream implements ObjectOutput, ObjectStreamConstants
{
    /** filter stream for handling block data conversion */
    private final BlockDataOutputStream bout;//对象数据输出流
    /** stream protocol version */
    private int protocol = PROTOCOL_VERSION_2;
    ** buffer for writing primitive field values */
    private byte[] primVals;
    /** if true, invoke writeObjectOverride() instead of writeObject() */
    private final boolean enableOverride;
}

先看构造

 public ObjectOutputStream(OutputStream out) throws IOException {
        verifySubclass();
	//关键是这个，构建对象数据流
        bout = new BlockDataOutputStream(out);
        handles = new HandleTable(10, (float) 3.00);
        subs = new ReplaceTable(10, (float) 3.00);
        enableOverride = false;
	//写流头部
        writeStreamHeader();
        bout.setBlockDataMode(true);
        if (extendedDebugInfo) {
            debugInfoStack = new DebugTraceInfoStack();
        } else {
            debugInfoStack = null;
        }
    }
  /**
     * The writeStreamHeader method is provided so subclasses can append or
     * prepend their own header to the stream.  It writes the magic number and
     * version to the stream.
     *写流版本号和流魔数
     * @throws  IOException if I/O errors occur while writing to the underlying
     *          stream
     */
    protected void writeStreamHeader() throws IOException {
        bout.writeShort(STREAM_MAGIC);
        bout.writeShort(STREAM_VERSION);
    }

再来一下BlockDataOutputStream，BlockDataOutputStream为ObjectOutputStream的静态内部类

 private static class BlockDataOutputStream
        extends OutputStream implements DataOutput
    {
        /** maximum data block length */
        private static final int MAX_BLOCK_SIZE = 1024;
        /** maximum data block header length */
        private static final int MAX_HEADER_SIZE = 5;
        /** (tunable) length of char buffer (for writing strings) */
        private static final int CHAR_BUF_SIZE = 256;

        /** buffer for writing general/block data ，存放对象序列化数据*/
        private final byte[] buf = new byte[MAX_BLOCK_SIZE];
        /** buffer for writing block data headers，存放数据头部 */
        private final byte[] hbuf = new byte[MAX_HEADER_SIZE];
        /** char buffer for fast string writes ，这个用于直接写原始类型*/
        private final char[] cbuf = new char[CHAR_BUF_SIZE];

        /** block data mode */
        private boolean blkmode = false;
        /** current offset into buf */
        private int pos = 0;

        /** underlying output stream */
        private final OutputStream out;
        /** loopback stream (for data writes that span data blocks)，写原始数据的输出流 */
        private final DataOutputStream dout;

        /**
         * Creates new BlockDataOutputStream on top of given underlying stream.
         * Block data mode is turned off by default.
         */
        BlockDataOutputStream(OutputStream out) {
            this.out = out;
            dout = new DataOutputStream(this);
        }

再看DataOutputStream
//DataOutputStream（DataOutput），主要用于写原始类型数据，int，float，String，double等

public class DataOutputStream extends FilterOutputStream implements DataOutput {
    /**
     * The number of bytes written to the data output stream so far.
     * If this counter overflows, it will be wrapped to Integer.MAX_VALUE.
     */
    protected int written;

    /**
     * bytearr is initialized on demand by writeUTF
     */
    private byte[] bytearr = null;

    /**
     * Creates a new data output stream to write data to the specified
     * underlying output stream. The counter written is
     * set to zero.
     *
     * @param   out   the underlying output stream, to be saved for later
     *                use.
     * @see     java.io.FilterOutputStream#out
     */
    public DataOutputStream(OutputStream out) {
        super(out);
    }

从上面可以看出，ObjectOutputStream的构造，主要是构造对象，对象输出流BlockDataOutputStream，BlockDataOutputStream主要是写序列化的流数据，BlockDataOutputStream中有一个存放序列化数据
的缓存区，头部数据缓冲区，原始类型数据缓冲区，其中关联一个原始类型输出流DataOutputStream，（DataOutput）主要用于写原始类型数据，int，float，String，double等;同时写流版本号和流魔数。

现在来看一下如何对象序列化：

public final void writeObject(Object obj) throws IOException {
       ...
        try {
	    //委托给writeObject0
            writeObject0(obj, false);
        } 
	...
    }

//序列化对象

private void writeObject0(Object obj, boolean unshared)
        throws IOException
    { 
         try {
            // handle previously written and non-replaceable objects
            int h;
            if ((obj = subs.lookup(obj)) == null) {
                writeNull();
                return;
            } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                writeHandle(h);
                return;
            } else if (obj instanceof Class) {
	        //如果是Class对象，则调用writeClass
                writeClass((Class) obj, unshared);
                return;
            } else if (obj instanceof ObjectStreamClass) {
	        //如果是对象序列化流类型writeClassDesc
                writeClassDesc((ObjectStreamClass) obj, unshared);
                return;
            }
	    ...
	    // remaining cases
            if (obj instanceof String) {
	        //如果对象为String直接调用writeString
                writeString((String) obj, unshared);
            } else if (cl.isArray()) {
	       //Array
                writeArray(obj, desc, unshared);
            } else if (obj instanceof Enum) {
	    //枚举
                writeEnum((Enum) obj, desc, unshared);
            } else if (obj instanceof Serializable) {
	    //序列化兑现跟这个是关键
                writeOrdinaryObject(obj, desc, unshared);
	    }
	    ....     
}

//如果是Class对象，则调用writeClass

writeClass((Class) obj, unshared);

//序列化对象类型

private void writeClass(Class cl, boolean unshared) throws IOException {
        bout.writeByte(TC_CLASS);
	//写流对象
        writeClassDesc(ObjectStreamClass.lookup(cl, true), false);
        handles.assign(unshared ? null : cl);
    }

来看这一句：

ObjectStreamClass.lookup(cl, true)

先看一下ObjectStreamClass对象

public class ObjectStreamClass implements Serializable {

    /** serialPersistentFields value indicating no serializable fields */
    //序列化对象属相描述
    public static final ObjectStreamField[] NO_FIELDS =
        new ObjectStreamField[0];
   /** reflection factory for obtaining serialization constructors */
    private static final ReflectionFactory reflFactory =
        AccessController.doPrivileged(
            new ReflectionFactory.GetReflectionFactoryAction());  
  private static class Caches {
        /** cache mapping local classes -> descriptors,类描述缓存 */
        static final ConcurrentMap> localDescs =
            new ConcurrentHashMap<>();

        /** cache mapping field group/local desc pairs -> field reflectors */
        static final ConcurrentMap> reflectors =
            new ConcurrentHashMap<>();

        /** queue for WeakReferences to local classes */
        private static final ReferenceQueue> localDescsQueue =
            new ReferenceQueue<>();
        /** queue for WeakReferences to field reflectors keys */
        private static final ReferenceQueue> reflectorsQueue =
            new ReferenceQueue<>();
    }
     /** class associated with this descriptor (if any) */
    private Class cl;
    /** name of class represented by this descriptor */
    private String name;
    /** serialVersionUID of represented class (null if not computed yet) */
    private volatile Long suid;

    /** true if represents dynamic proxy class */
    private boolean isProxy;
    /** true if represents enum type */
    private boolean isEnum;
    /** true if represented class implements Serializable */
    private boolean serializable;
    /** true if represented class implements Externalizable */
    private boolean externalizable;
    /** true if desc has data written by class-defined writeObject method */
    private boolean hasWriteObjectData;
     /** exception (if any) thrown while attempting to resolve class */
    private ClassNotFoundException resolveEx;
    /** exception (if any) to throw if non-enum deserialization attempted */
    private ExceptionInfo deserializeEx;
    /** exception (if any) to throw if non-enum serialization attempted */
    private ExceptionInfo serializeEx;
    /** exception (if any) to throw if default serialization attempted */
    private ExceptionInfo defaultSerializeEx;

    /** serializable fields */
    private ObjectStreamField[] fields;
    /** aggregate marshalled size of primitive fields */
    private int primDataSize;
    /** number of non-primitive fields */
    private int numObjFields;
    /** reflector for setting/getting serializable field values */
    private FieldReflector fieldRefl;
    /** data layout of serialized objects described by this class desc */
    private volatile ClassDataSlot[] dataLayout;

    /** serialization-appropriate constructor, or null if none */
    private Constructor cons;
    /** class-defined writeObject method, or null if none */
    private Method writeObjectMethod;
    /** class-defined readObject method, or null if none */
    private Method readObjectMethod;
    /** class-defined readObjectNoData method, or null if none */
    private Method readObjectNoDataMethod;
    /** class-defined writeReplace method, or null if none */
    private Method writeReplaceMethod;
    /** class-defined readResolve method, or null if none */
    private Method readResolveMethod;
}

回到这一句:

ObjectStreamClass.lookup(cl, true)

 static ObjectStreamClass lookup(Class cl, boolean all) {
        if (!(all || Serializable.class.isAssignableFrom(cl))) {
            return null;
        }
       //从缓存中获取对象流描述
        processQueue(Caches.localDescsQueue, Caches.localDescs);
        WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);
        Reference ref = Caches.localDescs.get(key);
	...
	if (entry == null) {
            try {
	        //没有则，创建一个流对象
                entry = new ObjectStreamClass(cl);
            } catch (Throwable th) {
                entry = th;
            }
            if (future.set(entry)) {
                Caches.localDescs.put(key, new SoftReference