java使用readClassDescriptor（）和resolveClass（）来允许序列化版本控制

Question

我正在研究Java序列化机制中的不同选项，以便在我们的类结构中为版本容忍存储提供灵活性（并且提倡使用不同的机制，您无需告诉我）

例如，如果只需要向后兼容，默认序列化机制可以处理添加和删除字段

不过，事实证明，重命名一个类或将其移动到另一个包要困难得多。我在this question中发现，我可以通过对ObjectInputStream子类化并重写readClassDescriptor（）来完成简单的类重命名和/或移动包：

    if (resultClassDescriptor.getName().equals("package.OldClass"))
        resultClassDescriptor = ObjectStreamClass.lookup(newpackage.NewClass.class);

这对于简单的重命名很好。但是如果你尝试添加或删除一个字段，你会得到一个java。伊奥。StreamCorruptedException。更糟糕的是，即使添加或删除了一个字段，并且然后重命名了该类，也会发生这种情况，这可能会导致多个开发人员或多个签入出现问题

根据我所做的一些阅读，我还尝试了重写resolveClass（），这是因为我们正确地将名称重新写入了新类，但没有加载旧类本身并对字段进行更改。但这来自于对序列化机制的一些细节的非常模糊的理解，我甚至不确定我是否找到了正确的方法

所以有两个确切的问题：

1. 为什么使用readClassDescriptor（）重新写入类名会导致 反序列化在正常、兼容的类更改中失败
2. 有没有办法使用resolveClass（）或其他机制来解决这个问题 这将允许类进化（添加和删除字段）并 重命名/重新打包

我四处张望，找不到一个与之类似的问题。无论如何，如果存在这样一个问题，请给我指出，但请仔细阅读这个问题，除非另一个问题确实回答了我的确切问题，否则不要关闭我

Answer 1

问题是readClassDescriptor应该告诉ObjectInputStream如何读取当前正在读取的流中的数据。如果你查看一个序列化的数据流，你会发现它不仅存储了数据，而且还存储了大量关于确切存在哪些字段的元数据。这就是允许序列化处理简单字段添加/删除的原因。然而，当您重写该方法并丢弃从流返回的信息时，您正在丢弃关于序列化数据中哪些字段的信息

我认为这个问题的解决办法是取super返回的值。readClassDescriptor（）并创建一个新的类描述符，该描述符返回新的类名，否则将返回旧描述符中的信息。（虽然，在观察ObjectStreamField时，它可能比这更复杂，但这是总体思路）

Answer 2

我最近也遇到了同样的问题，那就是StreamCorruptedException反序列化类的对象，这些类从一个包移动到另一个包，然后通过添加新字段以兼容的方式进化。虽然@gaponov answer最初解决了这个问题，但我发现下面的解决方案更合适，因为它不需要与类名混淆。使用ObjectInputStreamAdapter的类定义映射，而内部类ObjectInputStreamAdapter仅重新定义resolveClass方法：

    public class Deserializer {

    /*
     * Mapping that stores the specific new classes to use for old serialized
     * class names in order to transform old classes to the new ones for
     * compatibility reasons
     */
    private static final Map<String, Class<?>> classMapping = new HashMap<>();

    static {
        classMapping.put("com.example.old.SomeClass",
                SomeClass.class);
        classMapping.put("com.example.old.SomeClass2",
                SomeClass2.class);
    }

    public void deserialize(byte[] bytes) {
        try (ObjectInputStream o =
                new ObjectInputStreamAdapter(new ByteArrayInputStream(bytes))) {
            Object object = o.readObject();
            /* ... */
        } catch (Exception e) {
            throw new SerializationException("Cannot deserialize", e);
        }
    }

    /*
     * Adaptor that transform old classes to the new classes for compatibility
     * reasons
     */
    private class ObjectInputStreamAdapter extends ObjectInputStream {

        public ObjectInputStreamAdapter(InputStream in) throws IOException {
            super(in);
        }

        @Override
        protected Class<?> resolveClass(ObjectStreamClass desc)
                throws IOException, ClassNotFoundException {
            Class<?> klazz = classMapping.get(desc.getName());
            if (klazz != null) {
                return klazz;
            } else {
                return super.resolveClass(desc);
            }
        }

    }

}

Answer 3

我和你一样，在灵活性方面也有同样的问题。 这里是我的readClassDescriptor（）版本

    static class HackedObjectInputStream extends ObjectInputStream
{

    /**
     * Migration table. Holds old to new classes representation.
     */
    private static final Map<String, Class<?>> MIGRATION_MAP = new HashMap<String, Class<?>>();

    static
    {
        MIGRATION_MAP.put("DBOBHandler", com.foo.valueobjects.BoardHandler.class);
        MIGRATION_MAP.put("DBEndHandler", com.foo.valueobjects.EndHandler.class);
        MIGRATION_MAP.put("DBStartHandler", com.foo.valueobjects.StartHandler.class);
    }

    /**
     * Constructor.
     * @param stream input stream
     * @throws IOException if io error
     */
    public HackedObjectInputStream(final InputStream stream) throws IOException
    {
        super(stream);
    }

    @Override
    protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException
    {
        ObjectStreamClass resultClassDescriptor = super.readClassDescriptor();

        for (final String oldName : MIGRATION_MAP.keySet())
        {
            if (resultClassDescriptor.getName().equals(oldName))
            {
                String replacement = MIGRATION_MAP.get(oldName).getName();

                try
                {
                    Field f = resultClassDescriptor.getClass().getDeclaredField("name");
                    f.setAccessible(true);
                    f.set(resultClassDescriptor, replacement);
                }
                catch (Exception e)
                {
                    LOGGER.severe("Error while replacing class name." + e.getMessage());
                }

            }
        }

        return resultClassDescriptor;
    }