FileDocCategorySizeDatePackage
EvolvedClass.javaAPI DocExample9265Wed Apr 19 11:21:24 BST 2000None

EvolvedClass

public class EvolvedClass extends Object
This example shows how to use the Serializable Fields API with Serialization, demonstrating that the class can define fields other than those already in the class to be serializable. This differs from just rewriting the writeObject method to customize the data format (see the Custom Data Format example) because, in this example, versioning support still holds. Using the Serializable Fields API, this example specifically changes the internal representation of a rectangle from x1,y1,x2,y2 implementation (see Original Class) to Point(x1,y1), Point(x2,y2) (see Evolved Class) while the external representation still remains x1, y1, x2, y2. This ensures bidirectional compatibility between the original and evolved representations. The original rectangle class (in OriginalClass.java) consists of four integers (x1, y1, x2, y2). Instead of four integers, the evolved rectangle class (in this file) has two Points as fields. In order for this evolved class to fulfill its contract with the original class, the evolved class saves its fields as four integers (x1, y1, x2, y2) instead of two points. By doing this the evolved class ensures bidirectional compatibility with the original class. To see how to run this: see OriginalClass.java Compiled and Tested with JDK1.2

Fields Summary
Constructors Summary
Methods Summary
public static voidmain(java.lang.String[] args)
There are two options: either a user can serialize an object or deserialize it. (using the -s or -d flag). These options allow for the demonstration of bidirection readability and writeability between the original and the evolved class. In other words, one can serialize an object here and deserialize it with the evolved class or vice versa.


        ARectangle orgClass = new ARectangle(100, 100, 102, 102);
        ARectangle newClass = null;

        boolean serialize = false;
        boolean deserialize = false;

        /* 
	 * see if we are serializing or deserializing.
         * The ability to deserialize or serialize allows
         * us to see the bidirectional readability and writeability
         */
        if (args.length == 1) {
            if (args[0].equals("-d")) {
		deserialize = true;
            } else if (args[0].equals("-s")) {
                serialize = true;
            } else {
                usage();
                System.exit(0);
            }
        } else {
            usage();
            System.exit(0);
        }

        /* 
	 * Serialize the original class if that's the option chosen
         */
        if (serialize) {
            try {
                FileOutputStream fo = new FileOutputStream("evolve.tmp");
                ObjectOutputStream so = new ObjectOutputStream(fo);
                so.writeObject(orgClass);
                so.flush();
            } catch (Exception e) {
                System.out.println(e);
                System.exit(1);
	    }
        }

        /* 
	 * Deserialize, if that's the option chosen and print the name
         * of the object, which will allow us to see who serialized the
         * object, the original class or the evolved class file
         */
        if (deserialize) {
            try {
                FileInputStream fi = new FileInputStream("evolve.tmp");
                ObjectInputStream si = new ObjectInputStream(fi);
                newClass = (ARectangle) si.readObject();
            } catch (Exception e) {
                System.out.println(e);
                System.exit(1);
            }
            System.out.println("Now printing deserialized object: ");
            System.out.println();
	    System.out.println(newClass);
        }
static voidusage()
Prints out the usage

        System.out.println("Usage:");
        System.out.println("      -s (in order to serialize)");
        System.out.println("      -d (in order to deserialize)");