In depth analysis of Java serialization mechanism and principle

      Public byte version = 100;

      Public byte count = 0;

In theory, only 2 bytes are needed to store these two fields, but in fact temp.out occupies 51bytes, which means that in addition to data, other descriptions of serialized objects are also included.
Java serialization algorithm

Serialization algorithms generally follow these steps:

In pieces output the class metadata related to the object instance.

In pieces recursively outputs the superclass description of the class until there are no more superclasses.

In pieces when the class metadata is complete, begin to output the actual data value of the object instance from the topmost superclass.

In pieces output instance data recursively from top to bottom

Let's use another example that covers all possible scenarios more completely:

    class parent implements Serializable {       
           int parentVersion = 10;       
    }  

    class contain implements Serializable{       
           int containVersion = 11;       
    }  

    public class SerialTest extends parent implements Serializable {       
           int version = 66;       
           contain con = new contain();                   
           public int getVersion() {       
                  return version;       
           }       
           public static void main(String args[]) throws IOException {       
                  FileOutputStream fos = new FileOutputStream("temp.out");       
                  ObjectOutputStream oos = new ObjectOutputStream(fos);       
                  SerialTest st = new SerialTest();       
                  oos.writeObject(st);       
                  oos.flush();       
                  oos.close();       
           }       
    } 

The format after serialization is as follows:

AC ED 00 05 73  72 00 0A 53 65 72 69 61 6C 54 65

73 74 05 52 81 5A AC 66 02 F6 02 00 02  07 00 49

76 65 72 73 69 6F 6E  4 c   00 03 63 6F 6E  74 00 09

4 c   63 6F 6E 74 61 69 6E 3B 78  72 00 06 70 61 72

65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 01  00 49

0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70

00   00   00   00 0 a   00   00   42   73, 72, 00, 07, 63, 6F, 6E, 74

61 69 6E FC BB E6 0E FB CB 60 C7 02 00 01  00 49

0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78

70   00   00   00   0 b

Let's take a closer look at what these bytes represent. At the beginning, see color:

The first step in the serialization algorithm is to output a description of the object's associated classes. The object shown in the example is an instance of the SerialTest class, so the description of the SerialTest class is printed next. See color:

Next, the algorithm outputs one of these fields, int  Version = 66; See color:

Then, the algorithm outputs the next field, contain con = new contain(); This is a little bit special, it's an object. When describing an object type reference, you need to use the JVM's standard object signature notation, see color:

Next, the algorithm will output the super class, which is the Parent class description, see the color:

Next, print the domain description of the parent class, int  ParentVersion = 100; See color:

So far, the algorithm has output for all the class descriptions. The next step is to print out the actual value of the instance object. This is where it starts from the parent Class field, see color:

There is also the domain for the SerialTest class:

The following bytes are interesting. The algorithm needs to describe the contain class. Remember, there is no description of the contain class.

The output contains a unique domain description, int  ContainVersion = 11;

At this point, the serialization algorithm checks whether or not there is a superclass contained, and if so, the output is followed.

Finally, the actual field value of the contain class is output.

OK, we discussed the mechanism and principle of Java serialization, hoping to help the students.