Java Serialization

Java applies an instrument, called article serialization where an item can be symbolized as a series of bytes that comprises the object's statistics as well as knowledge concerning the object's kind and the types of facts stored in the entity.

Following a serialized item has been written into a folder, it can be interpreted from the file and desterilized that is, the category information and bytes that signify the item and its facts can be utilized to restore the purpose in memory.

Most imposing is that the whole process is JVM self-governing, meaning an entity can be serialized on one stage and desterilized on a totally diverse platform.

Classes ObjectInputStream and ObjectOutputStream are high-height flows that hold the techniques for serializing and deserializing an item.

The ObjectOutputStream class encloses numerous write techniques for writing a variety of data types, except one technique in exacting stands out −

public final void writeObject(Object x) throws IOException

The over technique serializes an item and drives it to the production stream. Also, the ObjectInputStream class encloses the subsequent process for deserializing an item −

public final Object readObject() throws IOException, ClassNotFoundException

This technique recovers the subsequently Object out of the flow and deserializes it. The revisit worth is Object, so you will require throwing it to its fitting data type.

To exhibit how serialization efforts in Java, the example is going to utilize the Employee class that we argued early on in the book. Presume that we encompass the subsequent Employee class, which applies the Serializable line −

Example

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("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 java.io.Serializable interface.
• The entire arenas in the class ought to be serializable. If the ground is not serializable, it has to be marked fleeting.

If you are inquiring to recognize if a Java Standard Class is serializable or not, ensure the certification for the group. The test is easy: If the class executes java.io.Serializable, then it is serializable; otherwise, it's not.

Serializing an Object

The ObjectOutputStream class is utilized to serialize an Object. The subsequent SerializeDemo plan instantiates an Employee object and serializes it to a folder.

While the plan is done executing, a file forenamed employee.ser is generated. The lineup does not create any output, but revises the code and endeavor to resolve what the program is responsible for.

Note − When serializing an item to a file, the usual conference in Java is to furnish the file with a .ser extension.

Example

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deserializing an Object

The subsequent DeserializeDemo plan deserializes the Employee object developed in the SerializeDemo program. Learning the lineup and try to conclude its output −

Example

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

This will produce the following result:

Output

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Here are the following important points to be noted:

The endeavor/catch block tries to vicious circle a ClassNotFoundException, which is stated by the readObject() method. For a JVM to be intelligent to deserialize an objective, it must be capable to discover the bytecode for the division. If the JVM never discovers a class through the deserialization of an item, it chucks a ClassNotFoundException.

Observe that the revisit value of readObject() is cast to an Employee reference.

The worth of the SSN ground was 11122333 when the entity was serialized, but since the ground is transient, this price was not sent to the output flow. The SSN field of the deserialized Employee object is 0.

Here at Intellinuts, we have created a complete Java tutorial for Beginners to get started in Java.