我如何查看java序列化对象？

Question

I have an object from old Java code, and I now changed the serialized object code. I want to be able to read both the old files and the new files. I need a branching statement in readObject to do something like:

if (next object is int -- just poking, it might be an Object)
{
    // we know we are in version 1
} else {
    // read new version of object
}

is that possible to do?

Answer 1

if (object instanceof Integer) {
  ... Do stuff
} else {
  ... Do other stuff
}

EDIT: I suppose I should expand on this. You can check object types using instanceof but I'm not sure about being able to work with primatives like int or char .

Answer 2

The easiest way to do this is to keep the old member variables with their old types and add new member variables for new types. also, you must keep the serialVersionUID of the class the same. then, your readObject() implementation can do any necessary manipulation to transform the old data to new data.

Original Object:

public class MyObject {
   private static final long serialVersionUID = 1234L;

   private int _someVal;
}

New version:

public class MyObject {
   private static final long serialVersionUID = 1234L;

   private int _someVal;  //obsolete
   private String _newSomeVal;

    private void readObject(java.io.ObjectInputStream in)
      throws IOException, ClassNotFoundException
    {
      in.defaultReadObject();

      if(_someVal != 0) {
        // translate _someVal to _newSomeVal
      }
    }
}

I believe there are more complex options available as well using custom ObjectStreamField[] serialPersistentFields , ObjectInputStream.GetField and ObjectOutputStream.PutField .

Answer 3

Ok so basically the question is "How can we check with an ObjectInputStream whether the next field is a primitive or an object?" and the answer as far as I can see is: You can't.

Which means the best solution I can see to keep backwards compatibility is to never remove primitives from the original version - keeping useless information blows up the size a bit, but otherwise that's easy.

To add new fields, I can see two ways:

1. Keep the earlier message format identical and only add new objects at the end - you can then easily distinguish different versions by the message size (or more exactly you'll get an IOException when reading data of v2 when you get a v1 object). That's much simpler and generally preferred.

2. You can change objects from v1 to v2 and then do a simple instanceof check. If you want to add primitives is to store their wrapper versions (ie Integer et al). Can save you some bytes, but Java's serialization protocol was never efficient to begin with, so really that's unnecessary complicated.

Answer 4

ObjectInputStream will load and create an instance of the right class.

object = ois.readObject();

if (object instanceof YourNewShiny ){
    // new style object
} else if (object instanceof YourOldBusted ){
    // convert YourOldBusted to YourNewShiny
} else {
    throw new ToyOutOfPram();
}

This is all great if you have a new class, but if you have changed your class in an incompatible manner such that the ObjectInputStream cannot deserialise the old versions of the class into the new form. If this is the case you are pretty much stuffed.

Options:

• Revert your changes, and either do them compatibly ie add a serialVersionId, don't change the order of fields, only add new field, plus don't assume not null constraints
• Using an old version of the code read the serialised data, convert it to some intermediate form (xml,csv,etc) and then import this data into the new class definition and serialise it out
• manually re implement the ObjectInputStream to detect your class type (you can use the serialVersionId to stiff the type)

Only the first seems like a good idea to me.