2

How is Serialization id stored in the instance of the object ?

The Serialization id we declare in Java is static field;and static fields are not serialized.

There should be some way to store the static final field then. How does java do it ?

user2434
  • 6,339
  • 18
  • 63
  • 87

4 Answers4

3

The serialVersionUID is not stored in the instance of a "serialized" object, as it is an static field (it is part of the class, not part of the object).

Therefore, it is stored in the compiled bytecode if it is actually defined, otherwise it is computed. In the java specification's words:

If the class has defined serialVersionUID it is retrieved from the class. If the serialVersionUID is >not defined by the class, it is computed from the definition of the class in the virtual machine. If >the specified class is not serializable or externalizable, null is returned.

In the Stream Unique Identifiers section, the algorithm for such computation is explained.

This paragraph is noteworthy (that's why IDEs usually show a warning when a class implementing Serializable has not explicitly defined a serialVersionUID).

Note: It is strongly recommended that all serializable classes explicitly declare serialVersionUID values, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, and can thus result in unexpected serialVersionUID conflicts during deserialization, causing deserialization to fail.

catch23
  • 17,519
  • 42
  • 144
  • 217
jalopaba
  • 8,039
  • 2
  • 44
  • 57
  • A "relative" downvote. Had to make sure that Jiri's better answer goes on top (would not have downvoted otherwise). You completely ignore the core of the question, which is how does the JVM know the version of the serialized data (if the UID for it is not written into the stream, which of course it is, even though it is a static field). – Thilo Jun 12 '12 at 08:41
2

If you look in the java.io.ObjectStreamClass there you can see that it is actually being serialized. The following method:

java.io.ObjectOutputStream.writeClassDescriptor(ObjectStreamClass)

calls a method which calls the following method:

java.io.ObjectStreamClass.getSerialVersionUID()

Which either computes the serialVersionUID or uses the one declared in the class and found before in the call to the following method:

java.io.ObjectStreamClass.getDeclaredSUID(Class)

So it seems that this static field is an exception from the rule that static fields are not being serialized.

How to read it is described here.

Community
  • 1
  • 1
Jiri Patera
  • 3,140
  • 1
  • 20
  • 14
2

The serial version UID is not stored in objects; it's a static field so it is stored in the class definition. What happens is that when you serialize an object, information about its class has to be stored too; otherwise there would be no way to un-serialize the object. The information stored about the class includes its name and its serial version UID.

You can read the entire protocol here: http://docs.oracle.com/javase/6/docs/platform/serialization/spec/protocol.html

In summary, the entry for a new object is exactly:

newObject:
  TC_OBJECT classDesc newHandle classdata[]

Here classDesc is a descriptor of the class which can be either a declaration of a new class, a null reference, or a reference to a previously declared class:

classDesc:
  newClassDesc
  nullReference
  (ClassDesc)prevObject

The declaration of a new class establishes the class's name and serial version UID, a handle that can be used to refer to it later, and additional information on the class encoded as classDescInfo:

newClassDesc:
  TC_CLASSDESC className serialVersionUID newHandle classDescInfo
Joni
  • 108,737
  • 14
  • 143
  • 193
0

The serialVersionUID is a special field used by the serialization runtime. It's all described in the Java Doc for java.lang.Serializable

Nick Holt
  • 33,455
  • 4
  • 52
  • 58