What is Serialization

Advertisements

The basic concept of object serialization is the ability to read and write objects to byte streams. These streams can be used for saving session state information by servlets, for sending parameters for Remote Method Invocation (RMI) calls, for saving state information about JavaBean technology components, and for sending objects over the network, as well as many other tasks.

To do object serialization you use an ObjectOutputStream to save your objects and an ObjectInputStream to read them back. The serialization process deals with flattening out an object tree such that all the raw data that make up an object, including all the objects referenced by that object, get saved. And, when it's time to read back an object, the original object tree graph gets recreated. Special cases like circular references and multiple references to a single object are preserved such that when the tree graph gets recreated new objects don't magically appear where a reference to another object in the tree should be.

In order for an object to support the serialization process, the class must implement the Serializable interface. There are no methods in the interface; the interface just serves as a marker to say that a class can be serialized. However, just adding implements Serializable to a class definition doesn't automatically make a class Serializable. All the instance variables of said class must be Serializable, also. If they aren't and you try to serialize the class an exception would be thrown. To mark an instance variable as not for serialization, you add the transient keyword to the definition. Classes like java.awt.Image and java.lang.Thread, which contain platform-specific implementation information, are not Serializable and should be marked as transient.

transient Image image;


When you serialize an instance of a class, the only things that are saved are the non-static and non-transient instance data. Class definitions are not saved. They must be available when you try to deserialize an object.

The basic process of serializing an object is as follows:

ObjectOutputStream oos =
new ObjectOutputStream(anOutputStream);
Serializable serializableObject = ...
oos.writeObject(serializableObject);


Then, to read the the object back, deserialization, you do the reverse:

ObjectInputStream ois =
new ObjectInputStream(anInputStream);
Object serializableObject = ois.readObject();


The other thing that is frequently explained about serialization is overriding the readObject and writeObject methods to change the default serialization behavior. By overriding these methods you can provide additional information to the output stream, to be read back in at deserialization time:

private void writeObject(ObjectOutputStream oos)
    throws IOException {
  oos.defaultWriteObject();
  // Write/save additional fields
  oos.writeObject(new java.util.Date());
}

// assumes "static java.util.Date aDate;" declared
private void readObject(ObjectInputStream ois)
    throws ClassNotFoundException, IOException {
  ois.defaultReadObject();
  // Read/initialize additional fields
  aDate = (java.util.Date)ois.readObject();
}


One common reason to override readObject and writeObject is to serialize the data for a superclass that is not Serializable itself.

And, this is where most serialization explanations end.