How to deserialize persistent object if class has changed

Hi

I have a scenario where I am upgrading the version of a component.
An instance of a class from this component is used as a persistent object.

I saved some objects with the older version and now want to retrieve it. I know the changes in the class, can get my data from the persistent object ?

The serialVersionUID must remain the same or deserialization will fail. After that it should work; dropped fields will be ignored, and added fields will be set to defaults (null / 0 / '\0' / false).

Thanks Rob,

My serialVersionUID is the same, but datatypes of some fields have changed.
Some new fields have also been added, but as yosay they should be handled.
Also, the toString() method has changed

The only problem there would be the changed data types. I don't think serialization can handle that, but you would have to try first to make sure. Maybe it will work if primitive types are widened, or if reference types are assignable, but I doubt it to be honest.

A String is changed to int

Then I am afraid you have a problem. I wouldn't know right away how to solve this.

Rob Prime wrote:I wouldn't know right away how to solve this.

Do you think it is possible to solve this at all? If you change a String to an int in a class, you have to all intents and purposes created a different class. It is hardly going to serialise and deserialise at all.

I am trying to keep the String as a String with the same name and create a new int for the other variable..
Will test it and update what happens

Aniruddh Joshi wrote:I am trying to keep the String as a String with the same name and create a new int for the other variable..

Worked

thanks guys!

Instead of Serializable, use Eternalizable. Then write and read a version number. In the readExternal() method, check the version number and then read only those fields that are applicable to that version. Note that the serialVersionUID needs to be hard coded so that changes in the class do not cause the UID value to change.

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Object2
implements Externalizable
{
	private static final long	serialVersionUID = -5722183829628549906L; // DO NOT CHANGE
	private static final int	VERSION = 2; // increment if you change read/write
	private int				version = VERSION;
	private String			varX;
	private double			varY;
	
	// Default constructor required by Externalizable.
	public Object2()
	{
	}
	
	public Object2( String varX, double varY )
	{
		this.varX = varX;
		this.varY = varY;
	}
	
	// This method is declared in the Externalizable interface.
	// Note that transient fields need not be written out as long as they can
	// be re-computed during read.
	public void writeExternal( ObjectOutput out )
	throws IOException
	{
		out.writeInt( VERSION ); // always write version first
		out.writeUTF( varX );
		out.writeDouble( varY );
	}
	
	// This method is declared in the Externalizable interface.
	public void readExternal( ObjectInput in )
	throws IOException, ClassNotFoundException
	{
		version = in.readInt(); // always read version first
		if( version == VERSION )
		{
			varX = in.readUTF();
			varY = in.readDouble();
		}
                // Add other version readers here
		else
		{
			throw new IOException( "Object2.readExternal(): version " + Integer.toString( version ) + " is not supported." );
		}
	}
}