Externalizable in java

Before understanding Externalizable interface, you need to have idea about Serialization.You can read more about Serialization at Serialization in java.
Java provides mechanism called serialization to persists java objects in a form of ordered or 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.

Externalizable:

As name suggest it is externalilizing your serialization.If you want to customize your serialization mechanism then you can use it.It uses custom written mechanism to perform marshalling and unmarshalling of objects.Externalizable interface extends Serializable interface. If you implement this interface then you need to override following methods.

view plainprint?

1.     @Override
2.     public void readExternal(ObjectInput arg0) throws IOException,
4.             ClassNotFoundException {
6.     }
8.     @Override
9.     public void writeExternal(ObjectOutput arg0) throws IOException {
11.     }

Now lets see how serialization happens:
At sender side:
JVM checks if class implements externalizable or not.If it does then serialize object using writeExternal() method.If it does not implement externalizable but implements serializable , object is serialized using ObjectOutputStream.
At receiver side:
When object is reconstructed and it is externalizable , an instance is created using no args constructor and readExternal is called.If it is not externalizable but serializable , object is reconstructed using ObjectInputStream.
Lets start with example same as we have used in Serialization in java.
Create Employee.java in src->org.arpit.java2blog
Employee.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.Externalizable;
3. import java.io.IOException;
4. import java.io.ObjectInput;
5. import java.io.ObjectOutput;
7. public class Employee implements Externalizable{
9.  int employeeId;
10.  String employeeName;
11.  String department;
12.  String nationality;
14.  public Employee()
15.  {
17.  }
18.  public int getEmployeeId() {
19.   return employeeId;
20.  }
21.  public void setEmployeeId(int employeeId) {
22.   this.employeeId = employeeId;
23.  }
24.  public String getEmployeeName() {
25.   return employeeName;
26.  }
27.  public void setEmployeeName(String employeeName) {
28.   this.employeeName = employeeName;
29.  }
30.  public String getDepartment() {
31.   return department;
32.  }
33.  public void setDepartment(String department) {
34.   this.department = department;
35.  }
38.  public String getNationality() {
39.   return nationality;
40.  }
41.  public void setNationality(String nationality) {
42.   this.nationality = nationality;
43.  }
44.  @Override
45.  public void readExternal(ObjectInput in) throws IOException,
46.  ClassNotFoundException {
47.   employeeId=in.readInt();
48.   employeeName=(String) in.readObject();
50.  }
51.  @Override
52.  public void writeExternal(ObjectOutput out) throws IOException {
54.   out.writeInt(employeeId);
55.   out.writeObject(employeeName);
56.  }
57. }

you must have no args contructor if you implement externalizable.

Create ExternalizableMain.java in org.arpit.java2blog

ExternalizableMain.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
8. public class ExternalizableMain {
9.  /**
10.   * @author Arpit Mandliya
11.   */
12.  public static void main(String[] args) {
14.   Employee emp = new Employee();
15.   emp.setEmployeeId(101);
16.   emp.setEmployeeName(“Arpit”);
17.   emp.setDepartment(“CS”);
19.   //Serialize
20.   try
21.   {
22.    FileOutputStream fileOut = new FileOutputStream(“employee.ser”);
23.    ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
24.    outStream.writeObject(emp);
25.    outStream.close();
26.    fileOut.close();
27.   }catch(IOException i)
28.   {
29.    i.printStackTrace();
30.   }
32.   //Deserialize
33.   emp = null;
34.   try
35.   {
36.    FileInputStream fileIn =new FileInputStream(“employee.ser”);
37.    ObjectInputStream in = new ObjectInputStream(fileIn);
38.    emp = (Employee) in.readObject();
39.    in.close();
40.    fileIn.close();
41.   }catch(IOException i)
42.   {
43.    i.printStackTrace();
44.    return;
45.   }catch(ClassNotFoundException c)
46.   {
47.    System.out.println(“Employee class not found”);
48.    c.printStackTrace();
49.    return;
50.   }
51.   System.out.println(“Deserialized Employee…”);
52.   System.out.println(“Emp id: “ + emp.getEmployeeId());
53.   System.out.println(“Name: “ + emp.getEmployeeName());
55.  }
56. }

Run it :

When you run ExternalizableMain.java.You will get following output

view plainprint?

1. Deserialized Employee…
2. Emp id: 101
3. Name: Arpit

If you already have serializable,why you need externalizable at all!!:

• When you serialize any object using serializable, apart from fields, all objects that belong to object map and that can be reached using instance variable will also be serialized .for example :
  • If you have Employee class and its superclass is person then it will serialize all superclass objects (such as person) until it reaches “Object” class.

• Similarly if Employee has instance variable of address class then it will serialize whole object map of address also .

Do you really want this much overhead when all you want to serialize is employeeId and  employeeName

• JVM uses reflection when you use serializable which is quite slow.

• While serializing,information about class description which incluses description of its superclass and instance variable associated with that class also get stored in stream.Again this is also a performance issue

Inheritance in Externalization:

Now we will see how inheritance affects externalization.So there can be muliple cases whether super class is externalizable or not.If not then how will you handle that and how it works.Lets see by example.
We will create Person.java which will be superclass of Employee.

Case 1: What if super class does not implement Externalizable:

If superclass does not implements externalizable , you need to serialize superclass ‘s fields in subclass that implements Externalizable.

Person.java

view plainprint?

1. package org.arpit.java2blog;
2. public class Person {
4.  String name=“default”;
5.  String nationality;
7.  public Person()
8.  {
9.   System.out.println(“Person:Constructor”);
10.  }
12.  public Person(String name, String nationality) {
13.   super();
14.   this.name = name;
15.   this.nationality = nationality;
16.  }
18.  public String getName() {
19.   return name;
20.  }
22.  public void setName(String name) {
23.   this.name = name;
24.  }
26.  public String getNationality() {
27.   return nationality;
28.  }
30.  public void setNationality(String nationality) {
31.   this.nationality = nationality;
32.  }
34. }

Create Employee.java in org.arpit.java2blog
Employee.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.Externalizable;
3. import java.io.IOException;
4. import java.io.ObjectInput;
5. import java.io.ObjectOutput;
6. ;
8. public class Employee extends Person implements Externalizable{
10.  int employeeId;
11.  String department;
13.  public Employee()
14.  {
16.  }
17.  public Employee(int employeeId,String name,String department,String nationality)
18.  {
19.   super(name,nationality);
20.   this.employeeId=employeeId;
21.   this.department=department;
22.   System.out.println(“Employee:Constructor”);
23.  }
25.  public int getEmployeeId() {
26.   return employeeId;
27.  }
28.  public void setEmployeeId(int employeeId) {
29.   this.employeeId = employeeId;
30.  }
32.  public String getDepartment() {
33.   return department;
34.  }
35.  public void setDepartment(String department) {
36.   this.department = department;
37.  }
41. @Override
42. public void writeExternal(ObjectOutput out) throws IOException {
44.  /*since superclass does not implement externalizable, you need to serialize super class field in this class itself*/
45.  //superclass fields
46.  out.writeObject(name);
47.  out.writeObject(nationality);
49.  // its own fields
50.  out.writeInt(employeeId);
51.  out.writeObject(department);
52. }
54. @Override
55. public void readExternal(ObjectInput in) throws IOException,
56.   ClassNotFoundException {
57.  /*since superclass does not implement externalizable, you need to deserialize super class field in this class itself*/
58.  //superclass fields
59.  name=(String) in.readObject();
60.  nationality=(String) in.readObject();
62.  // its own fields
63.  employeeId=in.readInt();
64.  department=(String) in.readObject();
66. }
67. }

Create ExternalizableMain.java in org.arpit.java2blog

ExternalizableMain.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
8. public class ExternalizableMain {
10.  /**
11.   * @author Arpit Mandliya
12.   */
13.  public static void main(String[] args) {
15.   //Serialize
16.   Employee emp = new Employee(101,“Arpit”,“CS”,“Indian”);
17.   System.out.println(“Before serializing”);
18.   System.out.println(“Emp id: “ + emp.getEmployeeId());
19.   System.out.println(“Name: “ + emp.getName());
20.   System.out.println(“Department: “ + emp.getDepartment());
21.   System.out.println(“Nationality: “ + emp.getNationality());
22.   System.out.println(“************”);
23.   System.out.println(“Serializing”);
24.   try
25.   {
26.    FileOutputStream fileOut = new FileOutputStream(“employee.ser”);
27.    ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
28.    outStream.writeObject(emp);
29.    outStream.close();
30.    fileOut.close();
31.   }catch(IOException i)
32.   {
33.    i.printStackTrace();
34.   }
36.   //Deserialize
37.   System.out.println(“************”);
38.   System.out.println(“Deserializing”);
39.   emp = null;
40.   try
41.   {
42.    FileInputStream fileIn =new FileInputStream(“employee.ser”);
43.    ObjectInputStream in = new ObjectInputStream(fileIn);
44.    emp = (Employee) in.readObject();
45.    in.close();
46.    fileIn.close();
47.   }catch(IOException i)
48.   {
49.    i.printStackTrace();
50.    return;
51.   }catch(ClassNotFoundException c)
52.   {
53.    System.out.println(“Employee class not found”);
54.    c.printStackTrace();
55.    return;
56.   }
57.   System.out.println(“After serializing”);
58.   System.out.println(“Emp id: “ + emp.getEmployeeId());
59.   System.out.println(“Name: “ + emp.getName());
60.   System.out.println(“Department: “ + emp.getDepartment());
61.   System.out.println(“Nationality: “ + emp.getNationality());
62.  }
63. }

Run it :

When you run ExternalizableMain.java.You will get following output:

view plainprint?

1. Employee:Constructor
2. Before serializing
3. Emp id: 101
4. Name: Arpit
5. Department: CS
6. Nationality: Indian
7. ************
8. Serializing
9. ************
10. Deserializing
11. Person:Constructor
12. After serializing
13. Emp id: 101
14. Name: Arpit
15. Department: CS
16. Nationality: Indian

Case 2: What if super class implements Externalizable:

If superclass implements externalizable ,then it will also have readExternal() and writeExternal() method so it will serialize its own fields in these methods

Person.java

view plainprint?

1. package org.arpit.java2blog;
3. import java.io.Externalizable;
4. import java.io.IOException;
5. import java.io.ObjectInput;
6. import java.io.ObjectOutput;
8. public class Person implements Externalizable{
10.  String name=“default”;
11.  String nationality;
13.  public Person()
14.  {
15.   System.out.println(“Person:Constructor”);
16.  }
18.  public Person(String name, String nationality) {
19.   super();
20.   this.name = name;
21.   this.nationality = nationality;
22.  }
24.  public String getName() {
25.   return name;
26.  }
28.  public void setName(String name) {
29.   this.name = name;
30.  }
32.  public String getNationality() {
33.   return nationality;
34.  }
36.  public void setNationality(String nationality) {
37.   this.nationality = nationality;
38.  }
41.  @Override
42.  public void writeExternal(ObjectOutput out) throws IOException {
44.   out.writeObject(name);
45.   out.writeObject(nationality);
46.  }
48.  @Override
49.  public void readExternal(ObjectInput in) throws IOException,
50.  ClassNotFoundException {
51.   name=(String) in.readObject();
52.   nationality=(String) in.readObject();
54.  }
56. }

Create Employee.java in org.arpit.java2blog
Employee.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.Externalizable;
3. import java.io.IOException;
4. import java.io.ObjectInput;
5. import java.io.ObjectOutput;
6. ;
8. public class Employee extends Person implements Externalizable{
10.  int employeeId;
11.  String department;
13.  public Employee()
14.  {
16.  }
17.  public Employee(int employeeId,String name,String department,String nationality)
18.  {
19.   super(name,nationality);
20.   this.employeeId=employeeId;
21.   this.department=department;
22.   System.out.println(“Employee:Constructor”);
23.  }
25.  public int getEmployeeId() {
26.   return employeeId;
27.  }
28.  public void setEmployeeId(int employeeId) {
29.   this.employeeId = employeeId;
30.  }
32.  public String getDepartment() {
33.   return department;
34.  }
35.  public void setDepartment(String department) {
36.   this.department = department;
37.  }
41.  @Override
42.  public void writeExternal(ObjectOutput out) throws IOException {
44.   super.writeExternal(out);
45.   out.writeInt(employeeId);
46.   out.writeObject(department);
47.  }
49.  @Override
50.  public void readExternal(ObjectInput in) throws IOException,
51.  ClassNotFoundException {
53.   super.readExternal(in);
54.   employeeId=in.readInt();
55.   department=(String) in.readObject();
57.  }
58. }

Create ExternalizableMain.java in org.arpit.java2blog

ExternalizableMain.java:

view plainprint?

1. package org.arpit.java2blog;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
8. public class ExternalizableMain {
10.  /**
11.   * @author Arpit Mandliya
12.   */
13.  public static void main(String[] args) {
15.   //Serialize
16.   Employee emp = new Employee(101,“Arpit”,“CS”,“Indian”);
17.   System.out.println(“Before serializing”);
18.   System.out.println(“Emp id: “ + emp.getEmployeeId());
19.   System.out.println(“Name: “ + emp.getName());
20.   System.out.println(“Department: “ + emp.getDepartment());
21.   System.out.println(“Nationality: “ + emp.getNationality());
22.   System.out.println(“************”);
23.   System.out.println(“Serializing”);
24.   try
25.   {
26.    FileOutputStream fileOut = new FileOutputStream(“employee.ser”);
27.    ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
28.    outStream.writeObject(emp);
29.    outStream.close();
30.    fileOut.close();
31.   }catch(IOException i)
32.   {
33.    i.printStackTrace();
34.   }
36.   //Deserialize
37.   System.out.println(“************”);
38.   System.out.println(“Deserializing”);
39.   emp = null;
40.   try
41.   {
42.    FileInputStream fileIn =new FileInputStream(“employee.ser”);
43.    ObjectInputStream in = new ObjectInputStream(fileIn);
44.    emp = (Employee) in.readObject();
45.    in.close();
46.    fileIn.close();
47.   }catch(IOException i)
48.   {
49.    i.printStackTrace();
50.    return;
51.   }catch(ClassNotFoundException c)
52.   {
53.    System.out.println(“Employee class not found”);
54.    c.printStackTrace();
55.    return;
56.   }
57.   System.out.println(“After serializing”);
58.   System.out.println(“Emp id: “ + emp.getEmployeeId());
59.   System.out.println(“Name: “ + emp.getName());
60.   System.out.println(“Department: “ + emp.getDepartment());
61.   System.out.println(“Nationality: “ + emp.getNationality());
62.  }
63. }

Run it :

When you run ExternalizableMain.java.You will get following output:

view plainprint?

1. Employee:Constructor
2. Before serializing
3. Emp id: 101
4. Name: Arpit
5. Department: CS
6. Nationality: Indian
7. ************
8. Serializing
9. ************
10. Deserializing
11. Person:Constructor
12. After serializing
13. Emp id: 101
14. Name: Arpit
15. Department: CS
16. Nationality: Indian

In this example, since the Person class stores and restores its fields in its own writeExternal and readExternal methods, you dont need to save/restore the superclass fields in sub class but if you observe closely the writeExternal and readExternal methods of Employee class, you will find that you still need to first call the super.xxxx() methods that confirms the statement the externalizable object must also coordinate with its supertype to save and restore its state.

DownSides of Externalizable:

• If you make any change to your class definition, you need to maintain writeExternal() and readExternal accordingly.
• As we have seen in example,Sub class object has to coordinate with its superclass to save and store its state(by call super.xxxx() method from subclass)

For more Visit: http://www.quontrasolutions.com/blog/category/java