Make Java runtime ignore serialVersionUIDs?

by

If you have access to the code base, you could use the SerialVer task for Ant to insert and to modify the serialVersionUID in the source code of a serializable class and fix the problem once for all.

If you can’t, or if this is not an option (e.g. if you have already serialized some objects that you need to deserialize), one solution would be to extend ObjectInputStream. Augment its behavior to compare the serialVersionUID of the stream descriptor with the serialVersionUID of the class in the local JVM that this descriptor represents and to use the local class descriptor in case of mismatch. Then, just use this custom class for the deserialization. Something like this (credits to this message):

import java.io.IOException;
import java.io.InputStream;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class DecompressibleInputStream extends ObjectInputStream {

    private static Logger logger = LoggerFactory.getLogger(DecompressibleInputStream.class);
    
    public DecompressibleInputStream(InputStream in) throws IOException {
        super(in);
    }
    
    @Override
    protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
        ObjectStreamClass resultClassDescriptor = super.readClassDescriptor(); // initially streams descriptor
        Class localClass; // the class in the local JVM that this descriptor represents.
        try {
            localClass = Class.forName(resultClassDescriptor.getName()); 
        } catch (ClassNotFoundException e) {
            logger.error("No local class for " + resultClassDescriptor.getName(), e);
            return resultClassDescriptor;
        }
        ObjectStreamClass localClassDescriptor = ObjectStreamClass.lookup(localClass);
        if (localClassDescriptor != null) { // only if class implements serializable
            final long localSUID = localClassDescriptor.getSerialVersionUID();
            final long streamSUID = resultClassDescriptor.getSerialVersionUID();
            if (streamSUID != localSUID) { // check for serialVersionUID mismatch.
                final StringBuffer s = new StringBuffer("Overriding serialized class version mismatch: ");
                s.append("local serialVersionUID = ").append(localSUID);
                s.append(" stream serialVersionUID = ").append(streamSUID);
                Exception e = new InvalidClassException(s.toString());
                logger.error("Potentially Fatal Deserialization Operation.", e);
                resultClassDescriptor = localClassDescriptor; // Use local class descriptor for deserialization
            }
        }
        return resultClassDescriptor;
    }
}

More Related Contents:

  1. What is a serialVersionUID and why should I use it?
  2. Why generate long serialVersionUID instead of a simple 1L?
  3. Convert a JSON string to object in Java ME?
  4. Why does writeObject throw java.io.NotSerializableException and how do I fix it?
  5. Gson serialize a list of polymorphic objects
  6. How to serialize an object into a string
  7. What is Serialization?
  8. Java Serialization with non serializable parts
  9. Which is the best alternative for Java Serialization?
  10. Jackson: How to add custom property to the JSON without modifying the POJO
  11. Jackson – How to process (deserialize) nested JSON?
  12. How to serialize an object that includes BufferedImages
  13. Trouble with Gson serializing an ArrayList of POJO’s
  14. Java static serialization rules?
  15. How to serialize static data members of a Java class?
  16. Gson Serialize field only if not null or not empty
  17. How to serialize Java primitives using Jersey REST
  18. Serialize JavaFX components
  19. Use class name as root key for JSON Jackson serialization
  20. How do I use Google’s Gson API to deserialize JSON properly?
  21. How to serialize object to CSV file?
  22. java.io.InvalidClassException: local class incompatible:
  23. Does it matter what I choose for serialVersionUID when extending Serializable classes in Java?
  24. How does Java’s serialization work and when it should be used instead of some other persistence technique?
  25. Uses of readObject/writeObject in Serialization
  26. Java ByteBuffer to String
  27. When do I have to change the serialVersionUID?
  28. How to serialize Optional classes with Gson?
  29. Java serialization, UID not changed. Can I add new variables and method to the class?
  30. Java serialization, ObjectInputStream.readObject(), check if will block

Leave a Comment