de/serialize java objects across different applications using different package names

Question

I want to share java objects across different applications.

As long as I use the same package names in the different projects it works fine. But if I change the package names it doesn't work anymore.

I tried to solve this by extend the ObjectInputStream class and overriding the readClassDescriptor method.

But by doing so I get the following error:

java.io.StreamCorruptedException: invalid type code: 00

... dont know how to solve this problem.

Here is the code I use for the extended ObjectInputStream class:

public class MyObjectInputStream extends ObjectInputStream {

    public static Map<String, Class> classNameMapping = initclassNameMapping(); 

    private static Map<String, Class> initclassNameMapping(){
        Map<String, Class> res = new HashMap<String, Class>();
        //ipxTest is the name of the package where the objects got serialized
        res.put("ipxTest.IPX", interprojectxchangeTest.IPX.class); 
        res.put("ipxTest.A", interprojectxchangeTest.A.class);
        return Collections.unmodifiableMap(res);
    }

    public MyObjectInputStream(InputStream in) throws IOException {
        super(in);
        enableResolveObject(true);
    }


    protected MyObjectInputStream() throws IOException, SecurityException {
        super();
        enableResolveObject(true);
    }

    @Override
    protected java.io.ObjectStreamClass readClassDescriptor() 
            throws IOException, ClassNotFoundException {
        ObjectStreamClass desc = super.readClassDescriptor();
        if (classNameMapping.containsKey(desc.getName()))
            return ObjectStreamClass.lookup(classNameMapping.get(desc.getName()));
        return desc;
    }
}

The IPX and A classes both look equal in the different projects and have each the same serialID.

Archibold

These questions may be helpful: https://mcmap.net/q/748773/-serialization-in-java-invalid-type-code-00 and https://mcmap.net/q/722642/-java-io-streamcorruptedexception-invalid-type-code-00 – Arella

My question is: why the overwritten 'readClassDescriptor' method can't solve the problem described. that is: that the original class is not anymore accessible for the jvm under its original name ... – Archibold

Answer 1

My first suggestion is to make your implementation simple and stop fighting the framework - use the same package names across applications. I would suggest making a library out of the serializable classes, and sharing that among the implementations.

If you MUST serialize / deserialize across applications with different package names, then my suggestion would be to forego the built-in Java serialization, which is tightly tied to the class name and package name, and use something like Gson to serialize / deserialize.

Gson allows you to specify a TypeAdaper. You can create and register a TypeAdapter for each class that you will serialize/deserialize, and specify the class name (without the package name) as the 'type' when serializing, like the following example, but use getSimpleName() instead of getCanonicalName()

When deserializing, you'd have to add the correct package name to the "type"

You'd have to do the TypeAdapters individually for each application.

public class GsonTypeAdapter<T> implements JsonSerializer<T>, JsonDeserializer<T> {
    @Override
    public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) {
        JsonObject result = new JsonObject();
        result.add("type", new JsonPrimitive(src.getClass().getCanonicalName()));
        result.add("properties", context.serialize(src, src.getClass()));

        return result;
    }

    @Override
    public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {
        JsonObject jsonObject = json.getAsJsonObject();
        String type = jsonObject.get("type").getAsString();
        JsonElement element = jsonObject.get("properties");

        try {
            return context.deserialize(element, Class.forName(type));
        } catch (ClassNotFoundException cnfe) {
            throw new JsonParseException("Unknown element type: " + type, cnfe);
        }
    }
}

Intramundane

Answer 2

The Package name of the class is a fundamental part of its full name.

if matthiasboesinger is ur name then matthias is just ur first name to identify you, but boesinger part is sort of your unique name identifier.

similarly, in classes, the compiler identifies the class and their serialized objects with their complete name and not just the first name.

in case u change the package names, u lose the integrity of the class as different classes can exist in different packages with same name.

so what u are trying is not possible.

unless you write a adapter class which picks up data from the original class with package name and pumps the data into ur new package name class.

but thats just beating around the bush.

Fantail

My question is: why the overwritten 'readClassDescriptor' method can't solve the problem described. that is: that the original class is not anymore accessible for the jvm under its original name ... – Archibold