Description Eldon Metz 2003-01-24 16:04:28 EST

The following test class reproduces the problem with the serialization 
compatibility between the JDT compiler and the JDK 1.4 and JDK 1.3 compilers.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * This is a test class that illustrates a serialization incompatibility
 * between the eclipse and standard JDK compiler implementations.  The problem
 * manifests itself when trying to serialize bytecode compiled with one
 * compiler and then trying to deserialize it with bytecode compiled from
 * another compiler
 * 
 * @author eldonm
 */
public class SerializationTest implements Serializable {

    // (1) The SerializationTest.class reference is what is causing the problem
    private static String className = SerializationTest.class.getName();

    /**
     * Constructor for SerializationTest.
     */
    public SerializationTest() {
        super();
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            printUsage();
            System.exit(1);
        }

        if ("write".equals(args[0])) {
            SerializationTest test = new SerializationTest();
            ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream(args[1]));
            out.writeObject(test);
            out.close();
        } else if ("read".equals(args[0])) {
            ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(args[1]));
            SerializationTest test = (SerializationTest) in.readObject();
            in.close();
        } else {
            printUsage();
        }
    }

    static void printUsage() {
        System.out.println(
            "Usage: java SerializationTest write|read filename");
    }
}

To reproduce the problem, add this class to a java natured Eclipse project and 
execute it as a application after adding the parameters "write"  followed by 
the desired serialized file name of the test serialized file 
(e.g. "c:\\test.ser")

Then compile the same code with the JDK 1.3 or 1.4 compiler and execute the 
application with the read argument on the same test filename (e.g. java read 
c:\\test.ser").  

You will then see a stack trace similar to the following:

java.io.InvalidClassException: SerializationTest; local class incomp
atible: stream classdesc serialVersionUID = -6933307971724216872, local class 
se
rialVersionUID = -5182857768810774092
  at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java
:459)
  at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.
java:1521)
  at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.jav
a:1435)
  at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStrea
m.java:1626)
  at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:
1274)
  at java.io.ObjectInputStream.readObject(ObjectInputStream.java:3
24)
  at SerializationTest.main(Unknown Source)

The (1) comment in the code above is the cause of the problem.  The static 
string is assigned a value from the class using the java.lang.Class.getName() 
method.  This triggers the eclipse compiler to synthesize additional class 
structure as shown below (taken from the decompiled version of the bytecode 
for the class listing shown above):

// JDT

  private static String className;
  static Class class$0; /* synthetic field */

  static
  {
    className = SerializationTest.class.getName();
  }

// JDK 1.4

    static Class class$(String s)
    {
        return Class.forName(s);
        ClassNotFoundException classnotfoundexception;
        classnotfoundexception;
        throw new NoClassDefFoundError(classnotfoundexception.getMessage());
    }

    private static String className;
    static Class class$SerializationTest; /* synthetic field */

    static
    {
        className = (class$SerializationTest != null ?
class$SerializationTest : (class$SerializationTest =
class$("SerializationTest"))).getName();
    }

This difference between the two results in a different class signature, thus   
resulting in the serialization incompatibility included at the beginning of 
this report.