Externalizable Interface in Java

Serialization is the process of giving persistence storage to Java objects so that they can be restored at a later time. Classes can be made persistent in Java by implementing the Serializable interface. Serializable is a marker interface meaning that it has no methods within it. Any Serializable class can be passed on to ObjectOutputStream.writeObject(object) for saving the object state and a call back to ObjectInputStream.readObject() will get the object back from the storage.

also read:

• Java Tutorials
• Java EE Tutorials
• Design Patterns Tutorials
• Java File IO Tutorials
• What is transient keyword?

Since this is a default Serialization process, the Application cannot have a finer control over the Serialization process. Because, by default all the instance variables, except static and transient variables will undergo Serialization process.

Let us see in this article how to take full control over the Serialization process by depending on the Externalizable interface. This interface has two methods called writeExternal() and readExternal() that needs to be overridden for making up the Serialization process.
Let us say that we wish to make the following Movie class to implement the Externalizable interface for custom Serialization. Note that in writeExternal() method, we store all the fields to the Output Stream by calling the ObjectOutput.write###() methods. And during the restoration process, readExternal() will be called, where the implementation stores the appropriate values in their corresponding fields.
Movie.java

package tips.externaizable;
    public class Movie implements Externalizable{
        private String name;
        private long releaseYear;
        private String language;
        public Movie(){
        }
        public Movie(String name, long releaseYear, String language){
            this.name = name;
            this.releaseYear = releaseYear;
            this.language = language;
        }
        public String toString(){
            return name + " , " + releaseYear + " , " + language;
        }
        @Override
        public void readExternal(ObjectInput in)
        throws IOException,ClassNotFoundException {
            name = in.readUTF();
            releaseYear = in.readLong();
            language = in.readUTF();
        }
        @Override
        public void writeExternal(ObjectOutput out)
        throws IOException {
            out.writeUTF(name);
            out.writeLong(releaseYear);
            out.writeUTF(language);
        }
    }

Following is the Client program that makes use of the above Movie class. The Object Output Stream class comes into picture for saving the object state in a file called "movies". For retrieving the object back from the storage we use the Object Input Stream class.
MovieExternalizableTest.java

  package tips.externalizable;
    import java.io.*;
    public class MovieExternalizableTest {
        public static void main(String[] args) throws Exception{
            Movie harry = new Movie(
                "Harry Potter and the Order of Phoenix", 2007, "English");
            ObjectOutputStream output = new ObjectOutputStream(
                new FileOutputStream("movies"));
            output.writeObject(harry);
            output.close();
            ObjectInputStream input = new ObjectInputStream(
                new FileInputStream("movies"));
            harry = (Movie)input.readObject();
            System.out.println(harry);
            input.close();
        }
    }