[英]Gson adapter for a heterogeneous Multimap
我有一個Multimap<Class<?>, Object>
填充為
multimap.put(o.getClass, o)
即,根據對象的類別將每個對象放入適當的存儲桶中。 我需要使用Gson序列化和反序列化多圖。 所有對象都屬於沒有類型參數的簡單類。 我的意思是,每個人都可以使用gson.fromJson(json, someClass)
進行反序列化; 這里不需要TypeToken
。
如果有幫助,我可以使用TypeToken
或其他任何鍵; 我不在乎 如果有幫助,所有使用過的類都將屬於我的類。 我不想將多圖分成多個同類列表,因為會有數十個同類列表。 由於它實際上是ImmutableMultimap
,這意味着我想避免更多的行。
我嘗試過的:不值得一提。 我編寫或看到的適配器都沒有類似的功能。
如果我對您的理解正確,則可以相對容易地完成這種類型的適配器。
首先,讓我們創建一個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
密鑰轉換器:該轉換器非常簡單明了且具有自我描述性。 例如,可以在此處和此處找到更復雜的轉換策略(后者不完全支持數組)。
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]}
好的,讓我們繼續使isClassKeyMultimap
方法更智能。
我也想使用
Multimap<Class<Something>, Something>
。
我猜您在談論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;
臨時評論應解釋為什么先前的實施未涵蓋所有情況。 甚至,您可以編寫一個可重用的實用程序方法來識別原始類本身。
private static Type getRawClass(final Type type) {
if ( type instanceof ParameterizedType ) {
return ((ParameterizedType) type).getRawType();
}
return type;
}
然后可以將這兩張支票折疊成一張支票:
if ( getRawClass(actualTypeArg0) == Class.class ) {
return true;
}
==
在java.class.Class
實例上應該可以正常工作 ,因為它的實例是有效的flyweight,並且可以提高此處的可讀性。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.