据我了解 AutoValue 和 AutoValue: Gson Extension 的工作原理，您不能Map<String, List<Obj>>仅使用这些工具从给定的 JSON 反序列化，因为它们只是简单的源代码生成器。后者甚至声明为每个带有 AutoValue 注释的对象创建一个简单的Gson TypeAdapterFactory。
考虑到给定的 JSON Map<String, List<Obj>>，您可以：
- ...具有
Map<String, Wrapper>包装类包含的位置List<Obj>（并为每个带注释的类声明一个类型适配器@AutoValue），因此具有一个名为Wrapper.
- ... 实现 AutoValue 无法生成的自定义类型适配器：Gson Extension。
第二个选项听起来并不难，当 AutoValue 扩展无法为其他复杂情况生成类型适配器时，它可以帮助解决。
声明必要的类型标记
final class TypeTokens {
private TypeTokens() {
}
static final TypeToken<Map<String, List<Obj>>> mapStringToObjListTypeToken = new TypeToken<Map<String, List<Obj>>>() {
};
static final TypeToken<List<Obj>> objListTypeTypeToken = new TypeToken<List<Obj>>() {
};
}
实现自定义类型适配器工厂
Gson 类型适配器工厂用于解析（和绑定）特定类型的适配器，并在必要时将适配器绑定到 Gson 实例以处理任何 Gson 配置。
final class CustomTypeAdapterFactory
implements TypeAdapterFactory {
private static final TypeAdapterFactory customTypeAdapterFactory = new CustomTypeAdapterFactory();
static TypeAdapterFactory getCustomTypeAdapterFactory() {
return customTypeAdapterFactory;
}
@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
if ( typeToken.getType().equals(mapStringToObjListTypeToken.getType()) ) {
@SuppressWarnings({ "unchecked", "rawtypes" })
final TypeAdapter<T> castTypeAdapter = (TypeAdapter) getMapStringToObjectListTypeAdapter(gson);
return castTypeAdapter;
}
return null;
}
}
请注意，工厂的唯一职责是返回一个特殊类型的适配器，它可以跳过 JSON 中的包装器。如果工厂请求任何其他类型，返回null是安全的，并让 Gson 尝试选择其他类型的适配器最佳匹配（内置或您的配置）。
实现类型适配器
这实际上是 Auto Value: Gson Extension 似乎无法做到的。由于类型适配器本质上是面向流的，它们可能看起来太低级了，但这是 Gson 可以做的最好的事情，因为流是一种非常有效的技术，它也用于 Auto Value: Gson Extension 生成的内容。
final class MapStringToObjectListTypeAdapter
extends TypeAdapter<Map<String, List<Obj>>> {
private final TypeAdapter<List<Obj>> wrapperAdapter;
private MapStringToObjectListTypeAdapter(final TypeAdapter<List<Obj>> wrapperAdapter) {
this.wrapperAdapter = wrapperAdapter;
}
static TypeAdapter<Map<String, List<Obj>>> getMapStringToObjectListTypeAdapter(final Gson gson) {
return new MapStringToObjectListTypeAdapter(gson.getAdapter(objListTypeTypeToken));
}
@Override
@SuppressWarnings("resource")
public void write(final JsonWriter out, final Map<String, List<Obj>> value)
throws IOException {
if ( value == null ) {
// nulls must be written
out.nullValue();
} else {
out.beginObject();
for ( final Entry<String, List<Obj>> e : value.entrySet() ) {
out.name(e.getKey());
out.beginObject();
out.name("occupations");
wrapperAdapter.write(out, e.getValue());
out.endObject();
}
out.endObject();
}
}
@Override
public Map<String, List<Obj>> read(final JsonReader in)
throws IOException {
// if there's JSON null, then just return nothing
if ( in.peek() == NULL ) {
return null;
}
// or read the map
final Map<String, List<Obj>> result = new LinkedHashMap<>();
// expect the { token
in.beginObject();
// and read recursively until } is occurred
while ( in.peek() != END_OBJECT ) {
// this is the top-most level where varKey# occur
final String key = in.nextName();
in.beginObject();
while ( in.peek() != END_OBJECT ) {
final String wrapperName = in.nextName();
switch ( wrapperName ) {
case "occupations":
// if this is the "occupations" property, delegate the parsing to an underlying type adapter
result.put(key, wrapperAdapter.read(in));
break;
default:
// or just skip the value (or throw an exception, up to you)
in.skipValue();
break;
}
}
in.endObject();
}
in.endObject();
return result;
}
}
汽车价值生成工厂
与自定义类型适配器工厂不同，一些 Gson 类型适配器工厂已经生成并且可以处理类似的abstract类Obj（至少在您的源代码中，而不是生成的）。
@GsonTypeAdapterFactory
abstract class GeneratedTypeAdapterFactory
implements TypeAdapterFactory {
public static TypeAdapterFactory getGeneratedTypeAdapterFactory() {
return new AutoValueGson_GeneratedTypeAdapterFactory();
}
}
它是如何使用的
private static void dump(final Map<?, ?> map) {
for ( final Entry<?, ?> e : map.entrySet() ) {
out.print(e.getKey());
out.print(" => ");
out.println(e.getValue());
}
}
...
final Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(getGeneratedTypeAdapterFactory())
.registerTypeAdapterFactory(getCustomTypeAdapterFactory())
.create();
dump(gson.fromJson(json, mapStringToObjListTypeToken.getType()));
给出以下输出：
varKey1 => [Obj{name=name1, value=val1}, Obj{name=name2, value=val2}]
varKey2 => [Obj{name=name1, value=val1}, Obj{name=name2, value=val2 }]
如果仅从第一个选项中使用包装器，则输出如下：
varKey1 => Wrapper{occupations=[Obj{name=name1, value=val1}, Obj{name=name2, value=val2}]}
varKey2 => Wrapper{occupations=[Obj{name=name1, value=val1},对象{name=name2, value=val2}]}