serialVersionUID

hi guys

i didnt understand the reason for having serialVersionUID in

a class that implemts serializable interface

looking for your replies

regards
amir

It basically tells what version the class is. When you serialize an instance, you want to deserialize it with the same version of the class. If the version does not match, an exception will be thrown (InvalidClassException I think).

i have gone through this link

http://c2.com/ppr/wiki/JavaIdioms/AlwaysDeclareSerialVersionUid.html

but i am not satisfied by the explaination

regards
amir

Hi Amrithraj,

You do the following to understand serialVersionUID.

1- Serialize instances of your class.
2- Change the class definition, add method(s), remove member variables or add
3- Try to deserialize the instances you serialized in the step 1
You will get InvalidClassException because while serialization takes place, some information about your class in also saved as part of serialization.

OK!
serialVerisonUID at your rescue!
1- Define serialVersionUID in your class!
2- Now serialize the instances
3- Make chages to your class
4- Deserialize the instances, Aren't you happy because this time no InvalidException occured, because serialization process didn't take trouble
to generate serialVersionUID because you have defined it, and it is same (make sure you have not changed this)

Thanks and Regards,
cmbhatt

hi chandra

i would like to thank you for your reply

i will be very much thankful to you if you send

me a sample for doing this

i tried this by writing sample java class

i make the instance of the class serializable by implementing

serializable interface ,then how can i get them deserialize

regards
amir

Hi Amrithraj,

Sure I have written the code demonstrating the use of serialVersionUID for you,
Look at the following code,

package serialization;
import java.io.*;
 
class Employee implements Serializable{

/**
 * 
 */
//comment/ uncomment and see the result by 
//modifying the Employee class, before
//deserializing, as I have done (added display() method)
private final static long serialVersionUID=555L;

Employee() {

}
Employee(int id,String name) {
this.id=id;
this.name =name;
}
/* setter and getter method*/

public void setId(int id) {
this.id =id;
}
public void setName(String name) {
this.name =name;
}
public int getId() {
return id;
}
public String getName() {
return name;
}

public String toString() {
return "ID : " + getId() + "\n Name : " + name;
}

/* Comment this display() method while serializing the Employee instance(s) */
public void display(){}
//Uncomment when you have serialized, and going
//to deserialize

private int id;
private String name;

}
 
public class DemoSerial {
static File afile = new File("Employee.set");
    public DemoSerial() {
    }
    
    
    public static void main(String... args) {
    Employee emp = new Employee(1101,"Amrithraj");
        
    ObjectOutputStream out=null;
    //Line 1
    try{
    out = new  ObjectOutputStream(
    new BufferedOutputStream(new FileOutputStream(afile)));
    out.writeObject(emp);
    System.out.println("Object Serialized");
    out.close();
    }catch(FileNotFoundException fnfe) {
    System.err.println(fnfe); 
    System.exit(1);
    }catch(IOException ioe) {
    System.err.println(ioe);
    System.exit(1);  
    }
    //Line 2
    //Comment from Line 1 to Line 2 after 
    //you have done serialization
    
    //DeSerialization process
    
    ObjectInputStream in=null;
    emp=null;
    try{
    in = new ObjectInputStream(
    new BufferedInputStream(
    new FileInputStream(afile)));
    emp = (Employee)in.readObject(); //readObject() returns Object, that's why casting
    System.out.println(emp);
    }catch(ClassNotFoundException cnfe) {
    cnfe.printStackTrace();
    System.exit(1);
    }catch(IOException ioe) {
       ioe.printStackTrace();
       System.exit(1);
    }    
}
}

/*
* Once you have defined serialVersionUID for your
* class, the Java is not going to compute it for you;
* As a result you can change the definition of a class
* by adding removing methods, members or so while
* deserializing. The JVM wont show you error that
* serialVerionUID mismatch. Because you have constant
* serialVersionUID at every execution of your code.
*/

Got it Amrithraj? Any doubt please post?

Regards,
cmbhatt

yes chandra

your sample is simply awesome

thanks indeed
regards
amir

The version information is written into the serialisation stream, to ensure that one version of your code doesn't try and fail to read data written by another version.

By default, the version changes whenever fields or methods change in your code. So any slight change causes a failure.

However, by defining the version yourself using the serialVersionUID field, you can tell Java whether you believe the streams are compatible. Very often, changes to methods have no effect on whether the streams are compatible, and you want to ensure Java understands this, by having a serialVersionUID that doesn't change when methods change.

Sometimes, streams are compatible even when fields have changed. A field that's in the stream but not in the local class will be discarded. A field that's not in the stream but is in the local class will be initialised to its default. If you know that your code will cope with this, then use serialVersionUID to tell Java the streams are compatible.