Home Java Java - Serialization
Java - Serialization
Java provides a mechanism, called object serialization where an object can be represented
as a sequence of bytes that includes the object's data as well as information about the
object's type and the types of data stored in the object.
After a serialized object has been written into a file, it can be read from the file and
deserialized that is, the type information and bytes that represent the object and its data
can be used to recreate the object in memory.
Most impressive is that the entire process is JVM independent, meaning an object can be
serialized on one platform and deserialized on an entirely different platform.
Methods for Serializing and Deserializing an Object
Classes ObjectInputStream and ObjectOutputStream are high-level streams that
contain the methods for serializing and deserializing an object.
The ObjectOutputStream class contains many write methods for writing various data
types, but one method in particular stands out −
Syntax
public final void writeObject(Object x) throws IOException
The above method serializes an Object and sends it to the output stream. Similarly, the
ObjectInputStream class contains the following method for deserializing an object −
Syntax
public final Object readObject() throws IOException, ClassNotFoundException
This method retrieves the next Object out of the stream and deserializes it. The return
value is Object, so you will need to cast it to its appropriate data type.
How Serialization Works in Java?
To demonstrate how serialization works in Java, I am going to use the Employee class that
we discussed early on in the book. Suppose that we have the following Employee class,
which implements the Serializable interface −
Example to Demonstrate Working of Serialization in Java
public class Employee implements [Link] {
public String name;
public String address;
public transient int SSN;
public int number;
public void mailCheck() {
[Link]("Mailing a check to " + name + " " + address);
}
}
Notice that for a class to be serialized successfully, two conditions must be met −
The class must implement the [Link] interface.
All of the fields in the class must be serializable. If a field is not serializable, it must
be marked transient.
If you are curious to know if a Java Standard Class is serializable or not, check the
documentation for the class. The test is simple: If the class implements
[Link], then it is serializable; otherwise, it's not.
Serializing an Object
The ObjectOutputStream class is used to serialize an Object. The following SerializeDemo
program instantiates an Employee object and serializes it to a file.
When the program is done executing, a file named [Link] is created. The program
does not generate any output, but study the code and try to determine what the program
is doing.
Note − When serializing an object to a file, the standard convention in Java is to give the
file a .ser extension.
Example for Serializing an Object
import [Link];
import [Link];
import [Link];
public class SerializeDemo {
public static void main(String [] args) {
Employee e = new Employee();
[Link] = "Reyan Ali";
[Link] = "Phokka Kuan, Ambehta Peer";
[Link] = 11122333;
[Link] = 101;
try {
FileOutputStream fileOut = new FileOutputStream("[Link]");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
[Link](e);
[Link]();
[Link]();
[Link]("Serialized data is saved in
/tmp/[Link]");
} catch (IOException i) {
[Link]();
}
}
}
class Employee implements [Link] {
private static final long serialVersionUID = 1L;
public String name;
public String address;
public transient int SSN;
public int number;
public void mailCheck() {
[Link]("Mailing a check to " + name + " " + address);
}
}
Output
Serialized data is saved in [Link]
Deserializing an Object
The following DeserializeDemo program deserializes the Employee object created in the
earlier program. Study the program and try to determine its output −
Example for Deserializing an Object
import [Link];
import [Link];
import [Link];
public class DeserializeDemo {
public static void main(String [] args) {
Employee e = null;
try {
FileInputStream fileIn = new FileInputStream("[Link]");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) [Link]();
[Link]();
[Link]();
} catch (IOException i) {
[Link]();
return;
} catch (ClassNotFoundException c) {
[Link]("Employee class not found");
[Link]();
return;
}
[Link]("Deserialized Employee...");
[Link]("Name: " + [Link]);
[Link]("Address: " + [Link]);
[Link]("SSN: " + [Link]);
[Link]("Number: " + [Link]);
}
}
class Employee implements [Link] {
private static final long serialVersionUID = 1L;
public String name;
public String address;
public transient int SSN;
public int number;
public void mailCheck() {
[Link]("Mailing a check to " + name + " " + address);
}
}
Output
Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101
Importing Points About Serialization in Java
Here are following important points to be noted −
The try/catch block tries to catch a ClassNotFoundException, which is declared by
the readObject() method. For a JVM to be able to deserialize an object, it must be
able to find the bytecode for the class. If the JVM can't find a class during the
deserialization of an object, it throws a ClassNotFoundException.
Notice that the return value of readObject() is cast to an Employee reference.
The value of the SSN field was 11122333 when the object was serialized, but
because the field is transient, this value was not sent to the output stream. The SSN
field of the deserialized Employee object is 0.