I have some pb with a test following:

package com.lecam;

import java.io.*;

public class testFile implements java.io.Externalizable{

byte one_byte = 1;
int one_int = 1024;

public testFile() {
}

public void writeExternal(ObjectOutput stream) throws java.io.IOException {
stream.writeByte(one_byte);
stream.writeInt(one_int);
}

public void readExternal(ObjectInput stream) throws java.io.IOException {
one_byte = stream.readByte();
one_int = stream.readInt();
}

public static void main(String args1[]) {
System.out.print("Writing...");
try {
testFile SubFile = new testFile();
FileOutputStream fos = new FileOutputStream("c:\\test.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SubFile.writeExternal(oos);
oos.flush();
oos.close();
fos.close();
} catch (java.io.IOException e) {
e.printStackTrace();
} catch(Exception e) {
e.printStackTrace();
}

System.out.print("Reading...");
try {
FileInputStream fis = new FileInputStream("c:\\test.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
testFile tFile = new testFile();
tFile.readExternal(ois);
System.out.println("SubFile : ");
System.out.println("byte : "+(tFile.one_byte));
System.out.println("int : "+ (tFile.one_int));
ois.close();
fis.close();
} catch (java.io.IOException e) {
e.printStackTrace();
} catch(Exception e) {
e.printStackTrace();
}
System.out.print("END...");
}
}

question: the test.bin file should be 5 bytes (one byte + one int = 1 + 4 = 5 bytes)
but it is 11 bytes! I don't know why!
thanks

You have explained it in a simple, nice manner. Thanks a lot !

The presentation is so nice, simple. Thanks a lot

Ravi,

If you serialize an externalizeable object, it''s readExternal or writeExternal methods will automatically get called. So, the scenario you mention should never happen. When you implement Externalizable, you take control of the serialization completely, so the transient modifier will not have an effect on fields in the Externalizable object.

Excellent article. I had a concern with transient data serialization when we do a serialization with externalizable interface. I mean when I implement a class with externalizable and do a normal serialization without being used its readExternal or writeExternal calls, then the Transient data is still get serialized.
Can anyone update me on this point?

Good article. As the previous comment indicates, using Java serialization can introduce some problems when the objects are read in by a different version of the software. I don''t recommend using Java serialization for ''durable'' persistence for this reason. Using Externalizable can help, but for complex applications this encourages the programmer to blend the persistence and other, unrelated aspects into the same object, which is not the best design. I would recommend delegating the Externalizable implementation into another object in this case.

Very Good introductory material. However I would like to add a paragraph on class version management.
Upon a change of the code of your class if you try to read an old serialized data, you may experience error. Externalize interface is for now the safe way to prevent yourself from that.

Excellent article. Liked real-world experiences shared by author.

Awesome! Did not know about the alternative to Serializable which exposes your application.