用于映射<字符串、列表的自动值 Gson 类型适配器<Obj>>

Question

我正试图找到一种方法，使用AutoValue将JSON对象反序列化为Java类(也是Parcelable)

JSON响应通常采用的形式

{
"varKey1": {
"occupations": [
{
"value": "val1",
"name": "name1"
},
{
"value": "val2",
"name": "name2"
}
]
},
"varKey2": {
"occupations": [
{
"value": "val1",
"name": "name1"
},
{
"value": "val2",
"name": "name2"
}
]
}
}

其中CCD_ 1和CCD_。

我很难弄清楚使用AutoValue Gson的typeAdapter应该是什么样子，如果能提供任何帮助，我们将不胜感激。

Answer 1

据我所知，AutoValue和AutoValue:Gson Extension是如何工作的，您无法仅使用这些工具从给定的JSON反序列化Map<String, List<Obj>>，因为它们只是简单的源代码生成器。后者甚至声明，为每个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 Extensions生成的内容。

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类型适配器工厂已经生成，可以处理varKey10类，就像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=name 2，value=val 2｝]
varKey2＝>[Oj｛name=name1，value=val1}，Obj{name=name2，value=val2｝]

如果只使用第一个选项中的包装器，则输出如下：

varKey1=>Wrapper｛职业=[Obj｛name=name1，value=val1}，Obj｛name=name 2，value=val 2｝]}