20.8. Serialization of Object Graphs

When an object contains references to other objects, and they all implement Serializable, the entire object graph is serialized automatically.

In Java, an object can reference other objects, forming a structure known as an object graph. When you serialize an object, Java automatically serializes all the objects contained within it, as long as they implement the Serializable interface. This means you don’t have to manually serialize each object; the serialization process handles the entire structure for you.

Think of an object as a book in a library. If the book references other books or resources, when you check out the main book, all referenced materials are included in your checkout. In this analogy, checking out the main book represents serialization, where the entire collection of books (the object graph) is sent out in one go.

Cycles in the graph are handled using a reference table internally.

Cycles occur in object graphs when two objects reference each other, creating a loop. With Java's serialization mechanism, these cycles are addressed by maintaining a reference table. This table keeps track of all objects that have already been serialized, ensuring each object is serialized only once, which prevents infinite loops during the serialization process.

Imagine a group of friends where everyone has a friendship bracelet. If two friends exchange bracelets, they create a cycle of friendship. If you want to record this friendship but need to make sure you don't list it twice, you note each friend only once in your friendship journal. This is similar to how Java ensures that each object in a cycle is serialized only a single time.

Non-serializable objects in the graph will throw NotSerializableException.

If any object within the object graph does not implement the Serializable interface, attempting to serialize the entire graph will result in a NotSerializableException. This is Java's way of indicating that it cannot serialize the object due to its lack of appropriate interface, halting the serialization process to prevent incomplete serialization data.

Consider a suitcase that you are trying to pack. If you attempt to pack a non-foldable item into a suitcase that requires items to be folded, it won’t fit. This situation parallels the serialization process, where Java cannot 'pack' a non-serializable object into its serialized format, leading to an error.

--