Java offers several packages, of which the interface Serializable is one. It is present within the Java package java.io and is a type of marker interface. When defined as a marker interface, there are no methods or fields present in the interface. So, whenever any classes implement the interface, the interface is not required to implement any methods. The classes implement the interface if a class wants their instances to get serialized or get deserialized.
The mechanism of serialization is used for the conversion of an object state into a stream of bytes. This mechanism is carried out by using the ObjectOutputStream. The process of deserialization is just the opposite of the process of serialization. In this case, the byte stream is converted back to the object of Java. ObjectInputStream is used for deserialization.
Table of Contents
The conversion of the state of any object into a stream of bytes is known as serialization. And the opposite of serialization is deserialization. An object of Java can be converted into a stream of static bytes. This static stream can then be saved on a database, or it can also get transferred to a different network. The process of serialization is instance-dependent. This means that the serialization of objects can be carried out on one platform, and then the deserialization of the objects can be carried out on another platform. A particular type of marker interface, “Serializable,” is implemented for the serialization process. So, the classes eligible for serialization, i.e., the serializable class in Java, should implement the marker interface.
This mechanism of writing an object state into a stream of bytes is known as serialization. The mechanism is primarily used in JMS, EJB, JPA, RMI, and Hibernate technologies.
ObjectInputStream and the ObjectOutputStream are the forms of high-level classes that extend the java.io.InputStream and the java.io.OutputStream. The primitive types and the object graphs can be written to the OutputStream by the ObjectOutputStream in a byte
stream. The stream that results from the conversion can be read through the ObjectInputStream. So, for the serialization, the method writeObject() is called from the ObjectOutputStream and for the deserialization, the method readObject() is called from the ObjectInputStream class.
The method which is the most important in ObjectOutputStream is:
The above line of code is taken from https://www.baeldung.com/java-serialization.
In the above line of code, an object which is serializable is taken, and then it is converted into a stream or stream of bytes.
In the case of ObjectInputStream, the most critical method is:
The above line of code is taken from https://www.baeldung.com/java-serialization.
The above line of code can read the sequence of bytes and convert this stream of bytes into an object of Java. The original object can be cast back through this.
An illustration of the serialization process can be described below:
A class “Person” is considered for serialization. The static fields are not serialized, and they belong to some classes. The class fields can be ignored by using the keyword “transient” in the process of serialization.
The object of the person type can be saved to some local file, and then the value is read back in. The below-shown code can be used for this purpose.
ObjectOutputStream was used for saving the object state into a file through using the FileOutputStream. In this example, a file named “yourfile.txt” has been created in the project’s directory. Through the use of FileInputStream, the created file is loaded. This stream is then picked up by the ObjectInputStream and gets converted into a new object with the name p2. The state of the object loaded up is finally tested, and it gets matched with the original object’s state. The object which is loaded has to be cast explicitly to the typical person.
Caveats in Java serialization
1. Inheritance and Composition
Whenever a user implements the interface java.io.Serializable, all the class sub-classes that implement the interface become serializable. Also, if an object holds a reference to a different object, the objects referred to implement the interface are serializable separately; if these objects don’t implement the interface, then an exception will be thrown out. The exception thrown out will be NotSerializableException. Also, if suppose an array of objects is stored at a serializable object, all the array objects should be serialized. If no serialization of the objects happens, then it will throw the exception “NotSerializableException.”
2. Serial Version UID
For every class that implements the Serializable interface, a number is associated with each of the classes. The number is associated with the Java Virtual Machine. This is mainly done to verify that the objects which are loaded and saved have the exact attributes. Only if the attributes are the same, the objects would be compatible upon serialization. IDE’s generate these numbers automatically and are mainly based on the names of the class, its attributes, and the access modifiers associated with it. An exception, “InvalidClassException,” will be thrown if a different number results from the changes.
If a serialVersionUID is not declared by a serializable class, the JVM will automatically generate it during the run time. Although there will be automatic generation of the number, it is still recommended that the classes declare a serialVersionUID. This is because the serialVersionUID, which will be automatically generated, will be dependent on the compiler and may sometimes throw unexpected InvalidClassExceptions.
3. Custom serialization
A default way has been set in Java for serializing the objects. Java can override this default behavior. There is a way for custom serialization. It is particularly useful in cases where the object having unserializable attributes is being tried to be serialized. The serialization for such objects can be done through two methods within a class the user wants to be serialized. These two methods are:
The above two methods can be used to serialize the attributes into any forms that can be serialized, which were earlier unserializable.
Advantages of serialization in Java
One of the advantages of serialization in Java is that the state of an object can be traveled on a network.
The Java interface java.io.Serializable
java.io.Serializable is a marker interface which means that there are no methods and objects within the interface. The primary function of the marker interface is to mark the
classes of Java to give a particular capability to all the objects of the classes. Examples of marker interfaces are Remote and Cloneable.
The interface must be implemented by any class which uses the interface for serializing its objects. By default, the classes such as wrapper classes and the String class implement the interface java.io.Serializable.
A java serializable example is shown below.
In the above code, it can be observed that the class Student implements the interface Serializable. Therefore once the class implements the interface Serializable, the objects within the class can be converted into bytes of stream.
This class is used for writing the primitive types of data and the Java objects into the OutputStream. The object which supports the interface java.io.Serializable can be used for getting written into streams.
All the primitive data that were written through using the ObjectOutputStream is deserialized by using the ObjectInputStream.
An example of a Serializable interface in Java is shown below.
In this example, the class Student is going to be serialized. The method writeObject() of the class ObjectOutputStream, provides all the functionality for serializing the objects. The state of the object is saved in a file with the name f.txt.
The article discussed the concept of serialization in Java. It listed out the interfaces and the other important methods required for serializing the objects of a class. The process of serialization is always associated with an id or a number with every serializable class. This number is referred to as the SerialVersionUID. The main use of the SerialVersionUID is to verify the sender and the receiver for the object that is to be serialized. This is because both the sender and the receiver should be the same.
It is an important feature of the programming language Java. If you want to know more about such important features and concepts in Java and master your programming language skills, you can check the Software Engineering Courses offered by upGrad. If you are a working professional, the course is best suited for you. For any form of queries, our team of assistance can be contacted. You can also browse our website for the specific course and get detailed information.
What is the function of a serializable interface?
The interface helps in the conversion of an object state into the byte stream.
What is the interface that is used for serialization?
The interface java. io. Serializable is used for serialization.
Is it possible for an interface to implement the serializable interface?
Yes, the serializable interface can be extended.