链接： https://www.cnblogs.com/zhwj184/archive/2012/06/02/3027487.html
    https://www.cnblogs.com/zhwj184/archive/2012/06/04/3119633.html

    我们查看下ObjectOutputStream的writeObject()方法

    1. //final方法，不允许子类覆盖
    2. public final void writeObject(Object obj) throws IOException {
    3.     if (enableOverride) { //如果开启允许序列化被重写
    4.         writeObjectOverride(obj); //调用子类的序列化重写方法
    5.         return;
    6.     }
    7.     try {
    8.         writeObject0(obj, false);//调用默认的序列化过程
    9.     } catch (IOException ex) {
    10.         if (depth == 0) {
    11.             writeFatalException(ex);
    12.         }
    13.         throw ex;
    14.     }
    15. }

    如果要自定义这个序列化过程，则可以写一个子类，集成ObjectOutputStream，然后覆盖其两个方法

    1. protected ObjectOutputStream() throws IOException, SecurityException {
    2.     SecurityManager sm = System.getSecurityManager();
    3.     if (sm != null) {
    4.         sm.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
    5.     }
    6.     bout = null;
    7.     handles = null;
    8.     subs = null;
    9.     enableOverride = true;
    10.     debugInfoStack = null;
    11. }
    12. protected void writeObjectOverride(Object obj) throws IOException {
    14. }

    我们再看下具体的writeObject0()方法：

    1. private void writeObject0(Object obj, boolean unshared) throws IOException 
    2.     {
    3.         boolean oldMode = bout.setBlockDataMode(false);
    4.         depth++;
    5.         try {
    6.             // 先对obj实例的类信息进行序列化，
    7.             int h;
    8.             if ((obj = subs.lookup(obj)) == null) {
    9.                 writeNull();
    10.                 return;
    11.             } else if (!unshared && (h = handles.lookup(obj)) != -1) {//可以自定义class类信息的序列化handler
    12.                 writeHandle(h);
    13.                 return;
    14.             } else if (obj instanceof Class) { //类信息序列化
    15.                 writeClass((Class) obj, unshared);
    16.                 return;
    17.             } else if (obj instanceof ObjectStreamClass) { //类信息序列化，此时还包括serialVersionUID
    18.                 writeClassDesc((ObjectStreamClass) obj, unshared);
    19.                 return;
    20.             }
    22.             // check for replacement object
    23.             //这里还可以对序列化的类进行替换序列化
    24.             Object orig = obj;
    25.             Class cl = obj.getClass();
    26.             ObjectStreamClass desc;
    27.             for (;;) {
    28.                 // REMIND: skip this check for strings/arrays?
    29.                 Class repCl;
    30.                 desc = ObjectStreamClass.lookup(cl, true);
    31.                 if (!desc.hasWriteReplaceMethod() ||
    32.                     (obj = desc.invokeWriteReplace(obj)) == null ||
    33.                     (repCl = obj.getClass()) == cl)
    34.                 {
    35.                     break;
    36.                 }
    37.                 cl = repCl;
    38.             }
    39.             if (enableReplace) {
    40.                 Object rep = replaceObject(obj);
    41.                 if (rep != obj && rep != null) {
    42.                     cl = rep.getClass();
    43.                     desc = ObjectStreamClass.lookup(cl, true);
    44.                 }
    45.                 obj = rep;
    46.             }
    48.             // if object replaced, run through original checks a second time
    49.             //如果类信息被替换过，则需要进行第二次处理
    50.             if (obj != orig) {
    51.                 subs.assign(orig, obj);
    52.                 if (obj == null) {
    53.                     writeNull();
    54.                     return;
    55.                 } else if (!unshared && (h = handles.lookup(obj)) != -1) {
    56.                     writeHandle(h);
    57.                     return;
    58.                 } else if (obj instanceof Class) {
    59.                     writeClass((Class) obj, unshared);
    60.                     return;
    61.                 } else if (obj instanceof ObjectStreamClass) {
    62.                     writeClassDesc((ObjectStreamClass) obj, unshared);
    63.                     return;
    64.                 }
    65.             }
    67.             // remaining cases
    68.             //写入类实例对象的数据，第一次总是在此执行
    69.             if (obj instanceof String) {
    70.                 writeString((String) obj, unshared);
    71.             } else if (cl.isArray()) {
    72.                 writeArray(obj, desc, unshared);
    73.             } else if (obj instanceof Enum) {
    74.                 writeEnum((Enum) obj, desc, unshared);
    75.             } else if (obj instanceof Serializable) { //我们的bean需要实现Serializable接口，才能进行序列化
    76.                 writeOrdinaryObject(obj, desc, unshared);
    77.             } else {
    78.                 if (extendedDebugInfo) {
    79.                     throw new NotSerializableException(
    80.                         cl.getName() + "\n" + debugInfoStack.toString());
    81.                 } else {
    82.                     throw new NotSerializableException(cl.getName());
    83.                 }    
    84.             }
    85.         } finally {
    86.             depth--;
    87.             bout.setBlockDataMode(oldMode);
    88.         }
    89.     }

    我们先简单的看下如果是一个String，如何做这个序列化的过程：

    1. private void writeString(String str, boolean unshared) throws IOException {
    2.     handles.assign(unshared ? null : str); 
    3.     long utflen = bout.getUTFLength(str);
    4.     if (utflen <= 0xFFFF) {
    5.         bout.writeByte(TC_STRING);
    6.         bout.writeUTF(str, utflen);
    7.     } else {
    8.         bout.writeByte(TC_LONGSTRING);
    9.         bout.writeLongUTF(str, utflen);
    10.     }
    11. }

    bout的writeUTF()方法：

    1. void writeUTF(String s, long utflen) throws IOException {
    2.     if (utflen > 0xFFFFL) {
    3.         throw new UTFDataFormatException();
    4.     }
    5.     writeShort((int) utflen); //先写入长度，
    6.     if (utflen == (long) s.length()) {
    7.         writeBytes(s); //然后写入字节流
    8.     } else {
    9.         writeUTFBody(s);
    10.     }
    11. }

    很简单，就是写入一个字符串的一个字节的标示符，然后写入字符串的字节流。
    那么再看看writeOrdinaryObject(obj, desc, unshared)如何对一个bean进行序列化

    1. private void writeOrdinaryObject(Object obj, 
    2.                                  ObjectStreamClass desc, 
    3.                                  boolean unshared) 
    4.     throws IOException 
    5.     {
    6.         if (extendedDebugInfo) {
    7.             debugInfoStack.push(
    8.                 (depth == 1 ? "root " : "") + "object (class \"" + 
    9.                 obj.getClass().getName() + "\", " + obj.toString() + ")");
    10.         }
    11.         try {
    12.             desc.checkSerialize(); //检查下是否可以进行序列化，比如socket对象之类的，如果对象无法进行序列化，则抛出异常。
    14.             bout.writeByte(TC_OBJECT); //先写入一个字节的类对象的标示符
    15.             writeClassDesc(desc, false); //序列化对象的class类信息
    16.             handles.assign(unshared ? null : obj); //保存类的seariableID跟对象的映射关系
    17.             if (desc.isExternalizable() && !desc.isProxy()) { //如果我们自定义了对象的序列化过程，则调用对象的writeExternalData方法。如果实现Externalizable
    18.                                                               //    /** true if represented class implements Externalizable */
    19.                                                               // private boolean externalizable;
    20.                 writeExternalData((Externalizable) obj);
    21.             } else {
    22.                 writeSerialData(obj, desc); //否则调用默认的序列化方法
    23.             }
    24.         } finally {
    25.                 if (extendedDebugInfo) {
    26.                 debugInfoStack.pop();
    27.             }  
    28.         }
    29.     }

    然后我们先看看writeClassDesc(desc, false)的实现：

    1. private void writeClassDesc(ObjectStreamClass desc, boolean unshared) 
    2.     throws IOException 
    3.     {
    4.         int handle;
    5.         if (desc == null) {
    6.             writeNull();
    7.         } else if (!unshared && (handle = handles.lookup(desc)) != -1) {
    8.             writeHandle(handle);
    9.         } else if (desc.isProxy()) { //如果是proxy对象，则调用该序列化机制 ,isProxy的判断
    10.            //isProxy = Proxy.isProxyClass(cl); Returns true if and only if the specified class was dynamically generated to be a proxy class using the getProxyClass method or the newProxyInstance method. 
    11.             writeProxyDesc(desc, unshared);
    12.         } else {
    13.             writeNonProxyDesc(desc, unshared);
    14.         }
    15.     }
    17.     /**
    18.      * Writes class descriptor representing a dynamic proxy class to stream.
    19.      */
    20.     private void writeProxyDesc(ObjectStreamClass desc, boolean unshared) 
    21.         throws IOException 
    22.     {
    23.         bout.writeByte(TC_PROXYCLASSDESC); //写入代理对象的标示符
    24.         handles.assign(unshared ? null : desc);
    26.         Class cl = desc.forClass();
    27.         Class[] ifaces = cl.getInterfaces(); //如果是proxy对象，则写入对象的interfaces的名称
    28.         bout.writeInt(ifaces.length); //先写入interface个数
    29.         for (int i = 0; i < ifaces.length; i++) {
    30.             bout.writeUTF(ifaces[i].getName()); //再写入每个interface的名称
    31.         }
    33.         bout.setBlockDataMode(true);
    34.         annotateProxyClass(cl);
    35.         bout.setBlockDataMode(false);
    36.         bout.writeByte(TC_ENDBLOCKDATA); //结束标签
    38.         writeClassDesc(desc.getSuperDesc(), false);//递归写入父类的序列化信息，因为java是单继承，
    39.     }
    41.     /**
    42.      * Writes class descriptor representing a standard (i.e., not a dynamic
    43.      * proxy) class to stream.
    44.      */
    45.     private void writeNonProxyDesc(ObjectStreamClass desc, boolean unshared) 
    46.         throws IOException 
    47.     {
    48.         bout.writeByte(TC_CLASSDESC);//写入class对象的标示符
    49.         handles.assign(unshared ? null : desc);
    51.         if (protocol == PROTOCOL_VERSION_1) { //如果非代理类对象的具体class信息，查看下面的方法
    52.             // do not invoke class descriptor write hook with old protocol
    53.             desc.writeNonProxy(this);
    54.         } else {
    55.             writeClassDescriptor(desc); 
    56.         }
    58.         Class cl = desc.forClass();
    59.         bout.setBlockDataMode(true);
    60.         annotateClass(cl);
    61.         bout.setBlockDataMode(false);
    62.         bout.writeByte(TC_ENDBLOCKDATA);
    64.         writeClassDesc(desc.getSuperDesc(), false);//递归写入父类的序列化信息，因为java是单继承，
    65.     }

    writeClassDescriptor(desc)方法：

    1. throws IOException
    2.     {
    3.         desc.writeNonProxy(this);
    4.     }
    6.  void writeNonProxy(ObjectOutputStream out) throws IOException {
    7.         out.writeUTF(name);//写入类的名称
    8.         out.writeLong(getSerialVersionUID());//写入类的SerialVersionUID
    10.         byte flags = 0;
    11.         if (externalizable) {//是否实现externalizable接口
    12.             flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
    13.             int protocol = out.getProtocolVersion();
    14.             if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {
    15.                 flags |= ObjectStreamConstants.SC_BLOCK_DATA;
    16.             }
    17.         } else if (serializable) {//是否实现serializable接口
    18.             flags |= ObjectStreamConstants.SC_SERIALIZABLE;
    19.         }
    20.         if (hasWriteObjectData) {//是否有自定义的重写序列化方法
    21.             flags |= ObjectStreamConstants.SC_WRITE_METHOD;
    22.         }
    23.         if (isEnum) {
    24.             flags |= ObjectStreamConstants.SC_ENUM;//是否是枚举
    25.         }
    26.         out.writeByte(flags);
    28.         out.writeShort(fields.length); //遍历写入各个类的各个field字段类型名称等信息
    29.         for (int i = 0; i < fields.length; i++) {
    30.             ObjectStreamField f = fields[i];
    31.             out.writeByte(f.getTypeCode()); //typecode参考ObjectStreamField.java类
    32.             out.writeUTF(f.getName());
    33.             if (!f.isPrimitive()) {
    34.                 out.writeTypeString(f.getTypeString());
    35.             }
    36.         }
    37.     }

    typecode：

    1. case 'Z': type = Boolean.TYPE; break;
    2. case 'B': type = Byte.TYPE; break;
    3. case 'C': type = Character.TYPE; break;
    4. case 'S': type = Short.TYPE; break;
    5. case 'I': type = Integer.TYPE; break;
    6. case 'J': type = Long.TYPE; break;
    7. case 'F': type = Float.TYPE; break;
    8. case 'D': type = Double.TYPE; break;
    9. case 'L':
    10. case '[': type = Object.class; break;

    至此，对象obj的class相关信息已经全部写入。
    然后我们再查看具体写入obj数据的过程

    1. private void writeSerialData(Object obj, ObjectStreamClass desc) 
    2.     throws IOException 
    3.     {
    4.         ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
    5.         for (int i = 0; i < slots.length; i++) {
    6.             ObjectStreamClass slotDesc = slots[i].desc;
    7.             if (slotDesc.hasWriteObjectMethod()) { //Returns true if represented class is serializable (but not externalizable) and defines a conformant writeObject method. Otherwise, returns false.
    8.                 Object oldObj = curObj;
    9.                 ObjectStreamClass oldDesc = curDesc;
    10.                 PutFieldImpl oldPut = curPut;
    11.                 curObj = obj;
    12.                 curDesc = slotDesc;
    13.                 curPut = null;
    15.                 if (extendedDebugInfo) {
    16.                     debugInfoStack.push(
    17.                         "custom writeObject data (class \"" + 
    18.                         slotDesc.getName() + "\")");
    19.                 }        
    20.                 try {
    21.                     bout.setBlockDataMode(true);
    22.                     slotDesc.invokeWriteObject(obj, this);
    23.                     bout.setBlockDataMode(false);
    24.                     bout.writeByte(TC_ENDBLOCKDATA);
    25.                 } finally {
    26.                     if (extendedDebugInfo) {
    27.                         debugInfoStack.pop();
    28.                     }        
    29.                 } 
    31.                 curObj = oldObj;
    32.                 curDesc = oldDesc;
    33.                 curPut = oldPut;
    34.             } else {
    35.                 defaultWriteFields(obj, slotDesc); //写入对象的字段数据
    36.             }
    37.         }
    38.     }
    39.     private void defaultWriteFields(Object obj, ObjectStreamClass desc)
    40.         throws IOException
    41.     {
    42.         // REMIND: perform conservative isInstance check here?
    43.         desc.checkDefaultSerialize();
    45.         int primDataSize = desc.getPrimDataSize(); //先写入private field的数据
    46.         if (primVals == null || primVals.length < primDataSize) {
    47.             primVals = new byte[primDataSize];
    48.         }
    49.         desc.getPrimFieldValues(obj, primVals);
    50.         bout.write(primVals, 0, primDataSize, false);
    52.         ObjectStreamField[] fields = desc.getFields(false);
    53.         Object[] objVals = new Object[desc.getNumObjFields()];
    54.         int numPrimFields = fields.length - objVals.length;
    55.         desc.getObjFieldValues(obj, objVals);
    56.         for (int i = 0; i < objVals.length; i++) { //写入非private的数据
    57.             if (extendedDebugInfo) {
    58.                 debugInfoStack.push(
    59.                     "field (class \"" + desc.getName() + "\", name: \"" + 
    60.                     fields[numPrimFields + i].getName() + "\", type: \"" + 
    61.                     fields[numPrimFields + i].getType() + "\")");
    62.             }        
    63.             try {
    64.                 writeObject0(objVals[i], 
    65.                              fields[numPrimFields + i].isUnshared()); //递归调用writeObject0写入每个field的数据
    66.             } finally {
    67.                 if (extendedDebugInfo) {
    68.                     debugInfoStack.pop();
    69.                 }     
    70.             }        
    71.         }
    72.     }

    下面我们来分析下序列化后的字节流内容：
    先写一段测试代码：

    1. import java.io.File;
    2. import java.io.FileInputStream;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.ObjectInputStream;
    7. import java.io.ObjectOutputStream;
    8. import java.io.Serializable;
    10. public class SeriableTest {
    12.     public static void main(String[] args) throws FileNotFoundException, IOException {
    13.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("e:\\log\\aa.txt")));    
    14.         out.writeInt(123);
    15.         out.writeUTF("str12345");
    16.         out.close();
    18.         //        ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("e:\\log\\aa.txt")));
    19.         //        int a = in.readInt();
    20.         //        String test = in.readUTF();
    21.         //        System.out.println(a);
    22.         //        System.out.println(test);
    23.         //        in.close();
    24.     }
    26. }

    我们查看文件的内容：
    java的序列化机制原理分析 - 图1
    其中0xACED是序列化的头信息字段，在new ObjectOutputStream的时候写入：

    1. public ObjectOutputStream(OutputStream out) throws IOException {
    2.     verifySubclass();
    3.     bout = new BlockDataOutputStream(out);
    4.     handles = new HandleTable(10, (float) 3.00);
    5.     subs = new ReplaceTable(10, (float) 3.00);
    6.     enableOverride = false;
    7.     writeStreamHeader();//序列化内容先写入两个信息
    8.     bout.setBlockDataMode(true); //设置该参数为true，下面会用到
    9.     if (extendedDebugInfo) {
    10.         debugInfoStack = new DebugTraceInfoStack();
    11.     } else {
    12.         debugInfoStack = null;
    13.     }   
    14. }
    15. protected void writeStreamHeader() throws IOException {
    16.     bout.writeShort(STREAM_MAGIC);//写入一个序列化用到的魔法数
    17.     bout.writeShort(STREAM_VERSION);//写入一个序列化的版本号
    18. }
    20. public interface ObjectStreamConstants {
    22.     /**
    23.      * Magic number that is written to the stream header.
    24.      */
    25.     final static short STREAM_MAGIC = (short)0xaced;
    27.     /**
    28.      * Version number that is written to the stream header.
    29.      */
    30.     final static short STREAM_VERSION = 5;


    接下来的两个字节0x770E是在ObjectOutputStream close或者flush的时候会调用bout的close方法写入两个信息，
    0x77是序列化内容长度小于0xff时设置的，0x0E是内容的长度。

    1. public class ObjectOutputStream
    2.     extends OutputStream implements ObjectOutput, ObjectStreamConstants
    3. {  
    4.   public void close() throws IOException {
    5.     flush();
    6.     clear();
    7.     bout.close();
    8.     }

    然后bout.close()方法调用：

    1. private static class BlockDataOutputStream 
    2.     extends OutputStream implements DataOutput{
    4.     public void flush() throws IOException {
    5.         drain();
    6.         out.flush();
    7.     }
    9.     public void close() throws IOException {
    10.         flush();
    11.         out.close();
    12.     }
    13.     void drain() throws IOException {
    14.         if (pos == 0) {
    15.             return;
    16.         }
    17.         if (blkmode) {//这里为true
    18.             writeBlockHeader(pos);//然后写入关于序列化内容的两个信息
    19.         }
    20.         out.write(buf, 0, pos);
    21.         pos = 0;
    22.     }
    23.     private void writeBlockHeader(int len) throws IOException {
    24.         if (len <= 0xFF) {
    25.             hbuf[0] = TC_BLOCKDATA; //长度小于0xff时，写入BLOCKDATA的头 == 0x77
    26.             hbuf[1] = (byte) len;//写入内容的长度
    27.             out.write(hbuf, 0, 2);
    28.         } else {
    29.             hbuf[0] = TC_BLOCKDATALONG;
    30.             Bits.putInt(hbuf, 1, len);
    31.             out.write(hbuf, 0, 5);
    32.         }
    33.     }

    然后0x0000007B就是123了，0x0008是后面字符串的长度，接着0x7374723132333435就是字符串str12345了。

    我们再试试一个另外一个，我们写入一个bean

    1. import java.io.File;
    2. import java.io.FileInputStream;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.ObjectInputStream;
    7. import java.io.ObjectOutputStream;
    8. import java.io.Serializable;
    11. public class SeriableTest {
    13.     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
    14.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("e:\\log\\aa.txt")));    
    15.         out.writeObject(new Bean());
    16.         out.close();
    18.         ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("e:\\log\\aa.txt")));
    19.         Bean bean = (Bean) in.readObject();
    20.         System.out.println(bean.a + " " + bean.b);
    21.     }
    23. }
    25. class Bean implements Serializable{
    27.     private static final long serialVersionUID = -1710202516612576460L;
    28.     int a = 1;
    29.     int b = 2;
    30. }

    输出为：
    java的序列化机制原理分析 - 图2
    这里 前面的ACED0005跟上面的一样
    73表示这个一个TC_OBJECT对象

    1.  /**
    2.   * new Object.
    3.   */
    4. final static byte TC_OBJECT =  (byte)0x73;
    5. private void writeOrdinaryObject(Object obj, ObjectStreamClass desc, boolean unshared)
    6.     throws IOException 
    7.     {
    8.         if (extendedDebugInfo) {
    9.         debugInfoStack.push(
    10.         (depth == 1 ? "root " : "") + "object (class \"" + 
    11.         obj.getClass().getName() + "\", " + obj.toString() + ")");
    12.         }
    13.         try {
    14.         desc.checkSerialize();
    16.         bout.writeByte(TC_OBJECT); //先写入该对象的类型
    17.         writeClassDesc(desc, false); //写入class对象的描述信息
    18.         handles.assign(unshared ? null : obj);
    19.         if (desc.isExternalizable() && !desc.isProxy()) {
    20.         writeExternalData((Externalizable) obj);
    21.         } else {
    22.         writeSerialData(obj, desc); //写入实例对象的数据
    23.         }
    24.     } finally {
    25.         if (extendedDebugInfo) {
    26.             debugInfoStack.pop();
    27.         }  
    28.       }
    29.     }

    我们看下writeClassDesc(desc, false); //写入class对象的描述信息的
    下面写入的数据位：72 

    1. private void writeNonProxyDesc(ObjectStreamClass desc, boolean unshared) 
    2.     throws IOException 
    3. {
    4.     bout.writeByte(TC_CLASSDESC); //final static byte TC_CLASSDESC =     (byte)0x72;
    5.     handles.assign(unshared ? null : desc);
    7.     if (protocol == PROTOCOL_VERSION_1) {
    8.         // do not invoke class descriptor write hook with old protocol
    9.         desc.writeNonProxy(this);
    10.     } else {
    11.         writeClassDescriptor(desc); //写入类的描述信息
    12.     }
    14.     Class cl = desc.forClass();
    15.     bout.setBlockDataMode(true);
    16.     annotateClass(cl); //子类可以重载该方法自己写入class对象
    17.     bout.setBlockDataMode(false);
    18.     bout.writeByte(TC_ENDBLOCKDATA);// final static byte TC_ENDBLOCKDATA =    (byte)0x78;
    20.     writeClassDesc(desc.getSuperDesc(), false);//写入父类的信息 没有父类，最后写入0x70
    21. }

    writeClassDescriptor()最后调用的是下面这个方法：
    写入的是 00 08 67 72 67 2E 42 65 61 6E E8 44 23 DF 47 54 0B 34 02 00 02 49 00 01 61 49 00 01 62

    1. void writeNonProxy(ObjectOutputStream out) throws IOException {
    2.     out.writeUTF(name);//写入类的完整名称,我这里是org.Bean  2byte+7byte  
    3.     <span style="white-space: normal; background-color: #ffffff;">对应16进制为00 08 67 72 67 2E 42 65 61 6E </span>
    5.         out.writeLong(getSerialVersionUID());//写入bean的序列化id 8byte 对应为E8 44 23 DF 47 54 0B 34
    7.     byte flags = 0;
    8.     if (externalizable) {
    9.         flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
    10.         int protocol = out.getProtocolVersion();
    11.         if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {
    12.             flags |= ObjectStreamConstants.SC_BLOCK_DATA;
    13.         }
    14.     } else if (serializable) {
    15.         flags |= ObjectStreamConstants.SC_SERIALIZABLE;
    16.     }
    17.     if (hasWriteObjectData) {
    18.         flags |= ObjectStreamConstants.SC_WRITE_METHOD;
    19.     }
    20.     if (isEnum) {
    21.         flags |= ObjectStreamConstants.SC_ENUM;
    22.     }
    23.     out.writeByte(flags); //写入类的flag信息，1byte 02
    25.     out.writeShort(fields.length);//写入对象的序列化字段个数 这里=2，a，b， 2byte  00 02
    26.     for (int i = 0; i < fields.length; i++) {//遍历flag，写入每个flag的信息   49 00 01 61 49 00 01 62
    27.         ObjectStreamField f = fields[i];
    28.         out.writeByte(f.getTypeCode()); //1byte 
    29.         out.writeUTF(f.getName()); //(2byte + 1byte) + (2byte+1byte)
    30.         if (!f.isPrimitive()) {//如果不是基本类型，写还需写入基本类型的信息，这里a和b都是基本类型
    31.             out.writeTypeString(f.getTypeString());
    32.         }
    33.     }
    34. }

    最后就是写入每个字段的值了 ,最后写入00 00 00 01 00 00 00 02 

    1. private void defaultWriteFields(Object obj, ObjectStreamClass desc)
    2.     throws IOException
    3. {
    4.     // REMIND: perform conservative isInstance check here?
    5.     desc.checkDefaultSerialize();
    7.     int primDataSize = desc.getPrimDataSize();
    8.     if (primVals == null || primVals.length < primDataSize) {
    9.         primVals = new byte[primDataSize];
    10.     }
    11.     desc.getPrimFieldValues(obj, primVals);
    12.     bout.write(primVals, 0, primDataSize, false);
    14.     ObjectStreamField[] fields = desc.getFields(false);
    15.     Object[] objVals = new Object[desc.getNumObjFields()];
    16.     int numPrimFields = fields.length - objVals.length;
    17.     desc.getObjFieldValues(obj, objVals);
    18.     for (int i = 0; i < objVals.length; i++) {
    19.         if (extendedDebugInfo) {
    20.         debugInfoStack.push(
    21.             "field (class \"" + desc.getName() + "\", name: \"" + 
    22.             fields[numPrimFields + i].getName() + "\", type: \"" + 
    23.             fields[numPrimFields + i].getType() + "\")");
    24.         }    
    25.         try {
    26.             writeObject0(objVals[i], 
    27.                  fields[numPrimFields + i].isUnshared()); //写入00  00 00 01 00 00 00 02  
    28.         } finally {
    29.             if (extendedDebugInfo) {
    30.                 debugInfoStack.pop();
    31.             }     
    32.         }    
    33.     }
    34. }