Internals of java Serialization : Which class initiates Serialization process?

Question

If I want to Serialize a java object, I just have to implement marker interface Serializable, which does not have any methods.

class Employee implements Serializable{
    private int id;
    private String name;

    /*
    private void writeObject(ObjectOutputStream out) throws IOException{
        System.out.println("in write object");
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
        System.out.println("in read object");
    }
    */

}

My queries (EDIT):

1. By implementing marker interface Serializable in my code, Java is serializing the my object. Which class is responsible for Serialization of java objects implementing Serializable interface ?

   What is the entry point for this process? Who calls ObjectOutputStream?

2. Even without implementing Externalizable interface, private methods of my class : readObject and writeObject have been invoked. These have been commented in above code to enable default Java Serializaiton. Why is it allowed in first place without explicitly implementing Externalizable interface?

EDIT: To make my question clear, why did Java allow private readObject & writeObject methods instead of forcing up to use Externalizable implementation to customize Serialization process.

From Java docs:

The writeExternal and readExternal methods of the Externalizable interface are implemented by a class to give the class complete control over the format and contents of the stream for an object and its supertypes. These methods must explicitly coordinate with the supertype to save its state. These methods supersede customized implementations of writeObject and readObject methods.

Are both mechanism not achieving the same result?

Answer 1

The class responsible for serializing objects is java.io.ObjectOutputStream. The deserialization is done in the java.io.ObjectInputStream class.

The JavaDoc of the class ObjectOutputStream contains also this:

Classes that require special handling during the serialization and deserialization process must implement special methods with these exact signatures:

private void readObject(java.io.ObjectInputStream stream)
   throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
   throws IOException;
private void readObjectNoData()
   throws ObjectStreamException;

Here is some pseudocode that shows how ObjectOutputStream works. I've omitted many details and part of the work is done in ObjectStreamClass.

class ObjectOutputStream {

    writeObject(obj) {
        writeObject0(obj);  
    }

    writeObject0(obj) {
        if (hasWriteReplaceMethod(obj)) {
            obj = obj.writeReplace();
        }
        writeOrdinaryObject(obj);
    }

    writeOrdinaryObject(obj) {
        if (isExternalizable(obj)) {
            writeExternalData(obj);
        } else {
            writeSerialdata(obj);
        }
    }

    writeExternalData(obj) {
        obj.writeExternal(this);
    }

    writeSerialData(obj) {
        if hasWriteObjectMethod(obj)
            obj.writeObject(this);
        else
            defaultWriteFields(obj);
    }
}

Answer 2

Which class initiates Serialization process?

java.io.ObjectOutputStream.

1. By implementing marker interface Serializable in my code, Java is serializing the my object. Which class is responsible for Serialization of java objects implementing Serializable interface?

java.io.ObjectOutputStream, again. You seem to be looking for something magical that isn't there.

2. Even without implementing Externalizable interface, private methods of my class : readObject and writeObject have been invoked. These have been commented in above code to enable default Java Serializaiton. Why is it allowed in first place without explicitly implementing Externalizable interface?

The methods you name have nothing to do with the Externalizable interface, which contains two quite different methods. The answer to your question is simply that that is how it was designed, so as to allow a degree of custom Serialization without requiring the Externalizable interface, and it is implemented via Reflection.

why did Java allow private readObject & writeObject methods instead of forcing up to use Externalizable implementation to customize Serialization process.

They aren't equivalent, so the question isn't meaningful. At the Serializable level, Java provides for automatically handling local and parent non-transient state, whereas in Externalizable you have to do that entirely yourself.

Are both mechanism not achieving the same result?

No.