用于异构 Multimap 的 Gson 适配器

Question

我有一个 Multimap<Class<?>, Object> 像

multimap.put(o.getClass, o)

即，每个对象根据其 class 放入适当的桶中。我需要使用 Gson 序列化和反序列化 multimap。所有对象都属于没有类型参数的简单 classes。我的意思是，它们中的每一个都可以使用 gson.fromJson(json, someClass); 反序列化；这里不需要 TypeToken。

如果有帮助，我可以使用 TypeToken 或其他任何内容作为密钥；我不在乎。如果有帮助，全部使用 classes subclass a class 我的。我不想要的是将 multimap 分成多个同类列表，因为它们会有数十个。因为它实际上是一个 ImmutableMultimap，这意味着我想避免更多行。

我试过的：不值一提。 None 我写的或看到的适配器做类似的事情。

Answer 1

如果我没理解错的话，你可以比较容易的完成这样一个类型的适配器。

首先，让我们创建一个 Multimap 类型的适配器。以下 Multimap 类型的适配器可以与任何多图一起使用，但是 Class 相关的键将在下面专门化。

final class MultimapTypeAdapter<K, V>
        extends TypeAdapter<Multimap<K, V>> {

    private final Converter<K, String> keyConverter;
    private final Function<? super K, ? extends TypeAdapter<V>> valueTypeAdapterProvider;

    private MultimapTypeAdapter(
            final Converter<K, String> keyConverter,
            final Function<? super K, ? extends TypeAdapter<V>> valueTypeAdapterProvider
    ) {
        this.keyConverter = keyConverter;
        this.valueTypeAdapterProvider = valueTypeAdapterProvider;
    }

    static <K, V> TypeAdapter<Multimap<K, V>> multimapTypeAdapter(
            final Converter<K, String> keyConverter,
            final Function<? super K, ? extends TypeAdapter<V>> valueTypeAdapterProvider
    ) {
        return new MultimapTypeAdapter<>(keyConverter, valueTypeAdapterProvider).nullSafe();
    }

    @Override
    @SuppressWarnings("resource")
    public void write(final JsonWriter jsonWriter, final Multimap<K, V> multimap)
            throws IOException {
        jsonWriter.beginObject();
        for ( final K key : multimap.keySet() ) {
            jsonWriter.name(keyConverter.convert(key));
            final TypeAdapter<? super V> typeAdapter = valueTypeAdapterProvider.apply(key);
            jsonWriter.beginArray();
            for ( final V value : multimap.get(key) ) {
                typeAdapter.write(jsonWriter, value);
            }
            jsonWriter.endArray();
        }
        jsonWriter.endObject();
    }

    @Override
    public Multimap<K, V> read(final JsonReader jsonReader)
            throws IOException {
        final ImmutableMultimap.Builder<K, V> multimapBuilder = new ImmutableMultimap.Builder<>();
        jsonReader.beginObject();
        while ( jsonReader.hasNext() ) {
            final K key = keyConverter.reverse().convert(jsonReader.nextName());
            final TypeAdapter<V> typeAdapter = valueTypeAdapterProvider.apply(key);
            jsonReader.beginArray();
            while ( jsonReader.hasNext() ) {
                final V value = typeAdapter.read(jsonReader);
                multimapBuilder.put(key, value);
            }
            jsonReader.endArray();
        }
        jsonReader.endObject();
        return multimapBuilder.build();
    }

}

现在，您可以创建一个简单的 Class 密钥转换器：该转换器非常简单明了且具有自我描述性。可以找到更复杂的转换策略，例如here and here（后者不完全支持数组）。

final class ClassKeyConverter
        extends Converter<Class<?>, String> {

    private static final Converter<Class<?>, String> classKeyConverter = new ClassKeyConverter();

    private ClassKeyConverter() {
    }

    static Converter<Class<?>, String> classKeyConverter() {
        return classKeyConverter;
    }

    @Override
    protected String doForward(final Class<?> a) {
        return a.toString();
    }

    @Override
    public Class<?> doBackward(final String b) {
        final Class<?> primitiveType = primitiveTypes.get(b);
        if ( primitiveType != null ) {
            return primitiveType;
        }
        final int prefix = b.startsWith(CLASS) ? CLASS.length()
                : b.startsWith(INTERFACE) ? INTERFACE.length()
                : -1;
        if ( prefix >= 0 ) {
            try {
                return Class.forName(b.substring(prefix));
            } catch ( final ClassNotFoundException ex ) {
                throw new RuntimeException(ex);
            }
        }
        throw new IllegalArgumentException(b);
    }

    private static final Map<String, Class<?>> primitiveTypes = ImmutableMap.<String, Class<?>>builder()
            .put("boolean", boolean.class)
            .put("byte", byte.class)
            .put("short", short.class)
            .put("int", int.class)
            .put("long", long.class)
            .put("float", float.class)
            .put("double", double.class)
            .put("char", char.class)
            .build();

    private static final String CLASS = "class ";
    private static final String INTERFACE = "interface ";

}

现在您可以创建一个类型适配器工厂来处理这样的多图：

final class ClassKeyMultimapTypeAdapterFactory
        implements TypeAdapterFactory {

    private static final TypeAdapterFactory classKeyMultimapTypeAdapterFactory = new ClassKeyMultimapTypeAdapterFactory();

    static final Type classKeyMultimapType = TypeToken.getParameterized(Multimap.class, Class.class, Object.class).getType();

    private ClassKeyMultimapTypeAdapterFactory() {
    }

    static TypeAdapterFactory classKeyMultimapTypeAdapterFactory() {
        return classKeyMultimapTypeAdapterFactory;
    }

    @Override
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        if ( !isClassKeyMultimap(typeToken) ) {
            return null;
        }
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> typeAdapter = (TypeAdapter<T>) multimapTypeAdapter(classKeyConverter(), type -> gson.getDelegateAdapter(this, TypeToken.get(type)));
        return typeAdapter;
    }

    private static boolean isClassKeyMultimap(final TypeToken<?> typeToken) {
        if ( Multimap.class.isAssignableFrom(typeToken.getRawType()) ) {
            final Type type = typeToken.getType();
            if ( type instanceof ParameterizedType ) {
                final ParameterizedType parameterizedType = (ParameterizedType) type;
                if ( Class.class.equals(parameterizedType.getActualTypeArguments()[0]) ) {
                    // We expect to process `Multimap<Class<?>, ?>` only
                    return true;
                }
            }
        }
        return false;
    }

}

终于可以测试一下了：

private static final Gson gson = new GsonBuilder()
        .disableHtmlEscaping()
        .registerTypeAdapterFactory(classKeyMultimapTypeAdapterFactory())
        .create();

public static void main(final String... args) {
    final Multimap<Class<?>, Object> multimapBefore = ImmutableMultimap.<Class<?>, Object>builder()
            .put(int.class, 2)
            .put(int.class, 3)
            .put(int.class, 4)
            .put(Integer.class, 2)
            .put(Integer.class, 3)
            .put(Integer.class, 4)
            .put(String.class, "foo")
            .put(String.class, "bar")
            .put(String.class, "baz")
            .build();
    System.out.println(multimapBefore);
    final String json = gson.toJson(multimapBefore, classKeyMultimapType);
    System.out.println(json);
    final Multimap<Class<?>, Object> multimapAfter = gson.fromJson(json, classKeyMultimapType);
    System.out.println(multimapAfter);
    if ( !multimapBefore.equals(multimapAfter) ) {
        throw new AssertionError("multimaps do not equal");
    }
}

输出：

{int=[2, 3, 4], class java.lang.Integer=[2, 3, 4], class java.lang.String=[foo, bar, baz]}
{"int":[2,3,4],"class java.lang.Integer":[2,3,4],"class java.lang.String":["foo","bar","baz"]}
{int=[2, 3, 4], class java.lang.Integer=[2, 3, 4], class java.lang.String=[foo, bar, baz]}

更新 1

好的，让我们继续使 isClassKeyMultimap 方法更智能一些。

I'd like to work with a Multimap<Class<Something>, Something>, too.

我猜你是在谈论 TypeToken 文字。是的，我使用 TypeToken.getParameterized(...) 忘记了 Class 实例也可以被参数化。要使其更智能，您只需向该方法添加额外的检查即可。

if ( Multimap.class.isAssignableFrom(typeToken.getRawType()) ) {
    final Type type = typeToken.getType();
    if ( type instanceof ParameterizedType ) {
        final ParameterizedType parameterizedType = (ParameterizedType) type;
        final Type actualTypeArg0 = parameterizedType.getActualTypeArguments()[0];
        // raw java.lang.Class (Class.class, Class.forName("java.lang.Class"), etc)
        if ( actualTypeArg0 == Class.class ) {
            return true;
        }
        // or maybe it's something like a Class<...> instance that:
        // * can be generated by javac when you parameterize a type (this is why Gson TypeToken's look "weird")
        // * or create a ParameterizedType instance yourself, say using TypeToken.getParameterized or your custom ParameterizedType implementation
        if ( actualTypeArg0 instanceof ParameterizedType && ((ParameterizedType) actualTypeArg0).getRawType() == Class.class ) {
            return true;
        }
    }
}
return false;

临时评论应该解释为什么以前的实施没有涵盖所有情况。更重要的是，您可以编写一个可重用的实用程序方法来识别原始 class 本身。

private static Type getRawClass(final Type type) {
    if ( type instanceof ParameterizedType ) {
        return ((ParameterizedType) type).getRawType();
    }
    return type;
}

然后可以将这两项检查合并为一张：

if ( getRawClass(actualTypeArg0) == Class.class ) {
    return true;
}

== should work just fine 有 java.class.Class 个实例，因为它的实例是有效的享元，可以提高这里的可读性。

用于异构 Multimap 的 Gson 适配器

Gson adapter for a heterogeneous Multimap

java

json

multimap

type-erasure

gson

更新 1