例如,有两个类
class A {
public int key;
public B b;
}
class B {
private final int key;
public int x;
public int y;
public B(int key) {
this.key = key;
}
}
因此,内部B实例的字段键必须与外部A实例的字段键完全相同。
B的实例创建者是:
public class B_InstanceCreator implements InstanceCreator<B> {
private final int key;
public B_InstanceCreator(int key) {
this.key = key;
}
@Override
public B createInstance(Type type) {
return new B(key);
}
}
如何为A创建类型适配器,在提取键之后创建(然后用于反序列化内部B)B_InstanceCreator?
答案 0 :(得分:1)
Gson似乎非常无国籍,有时会伤害。同一个故事与InstanceCreator
相关,其中上下文是通过构造函数或实现此接口的对象的setter传递的,就像您上面提到的那样。只有在反序列化key
类时才能获得A
,因为子节点的类不知道其父对象上下文。因此,您必须首先为A
类实现反序列化器(遗憾的是丢失注释,如@SerializedName
,@Expose
,@JsonAdapter
...):
final class AJsonDeserializer
implements JsonDeserializer<A> {
private static final JsonDeserializer<A> aJsonDeserializer = new AJsonDeserializer();
private AJsonDeserializer() {
}
static JsonDeserializer<A> getAJsonDeserializer() {
return aJsonDeserializer;
}
@Override
public A deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context) {
final JsonObject root = jsonElement.getAsJsonObject();
final A a = new A();
a.key = root.get("key").getAsJsonPrimitive().getAsInt();
a.b = createInnerGson(a.key).fromJson(root.get("b"), B.class);
return a;
}
private static Gson createInnerGson(final int key) {
return new GsonBuilder()
.registerTypeAdapter(B.class, (InstanceCreator<B>) type -> new B(key))
.create();
}
}
正如你在上面所看到的,它的另一个性能弱点是createInnerGson
实例化一个Gson构建器,一个实例创建器,最后是幕后的内部Gson实例(不知道它的成本是多少) 。但它似乎是将key
上下文传递给实例创建者的唯一方法。 (如果Gson能够实现一个fromJson
方法来覆盖 B
实例的状态(比如gson.merge(someJson, someBInstance)
之类的东西),那将是很好的 - 但是Gson只能生成新的反序列化值。)
JSON反序列化器可以如下使用(假设A
和B
在各自的toString
方法中实现了漂亮的印刷):
final Gson gson = new GsonBuilder()
.registerTypeAdapter(A.class, getAJsonDeserializer())
.create();
final A a = gson.fromJson("{\"key\":2048,\"b\":{\"x\":20,\"y\":30}}", A.class);
out.printf("%d, %d\n", a.key, a.b.key);
out.println(a);
输出:
2048, 2048
A{key=2048, b=B{key=2048, x=20, y=30}}
你知道,我有一个想法...... JsonDeserializer<A>
可能不是一个需要半手动A
反序列化的好主意。但是,一个替代解决方案是将一个真正的反序列化器嵌套到一种“阴影”通用反序列化器中,从而将整个反序列化作业委托给Gson。这里唯一的事情是你必须记住,“影子根”Gson实例应该用于你提到的最顶层的对象(根),否则它将无法正常工作或可能影响性能(参见如何在下面获得嵌套的Gson实例。
让我们先来看看这堂课。它不会自行进行反序列化,只是要求另一个Gson实例执行反序列化。它有两种工厂方法:一种用于JsonElement
到Gson
之间的直接映射,另一种用于执行两项操作,例如从JsonElement
提取密钥并将密钥委派给Gson
工厂(还记得上面讨论的InstanceCreator
的细节吗?)。这个反序列化器实际上只是获取根JSON元素。
final class GsonFactoryJsonDeserializer
implements JsonDeserializer<Object> {
private final Function<? super JsonElement, Gson> gsonFactory;
private GsonFactoryJsonDeserializer(final Function<? super JsonElement, Gson> gsonFactory) {
this.gsonFactory = gsonFactory;
}
static JsonDeserializer<Object> gsonFactoryJsonDeserializer(final Function<? super JsonElement, Gson> gsonFactory) {
return new GsonFactoryJsonDeserializer(gsonFactory);
}
static <K> JsonDeserializer<Object> gsonFactoryJsonDeserializer(final Function<? super JsonElement, ? extends K> jsonElementToKey,
final Function<? super K, Gson> keyToGson) {
return new GsonFactoryJsonDeserializer(jsonElementToKey.andThen(keyToGson));
}
@Override
public Object deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context)
throws JsonParseException {
final Gson gson = gsonFactory.apply(jsonElement);
return gson.fromJson(jsonElement, type);
}
}
下面的演示封装了GsonBuilder
工厂方法,以便按需创建新的GsonBuilder
实例,因为Gson构建器是有状态的,并且使用相同的实例可能会导致非常意外的行为。 gsonFactoryJsonDeserializer
正在使用第二个重载:分离密钥提取和注册B
类实例化器。如果外部和内部对象中的键不匹配(a.key
必须等于a.b.key
),则应用程序应该抛出一个绝不应该在生产中发生的断言错误。
private static GsonBuilder createDefaultRealGsonBuilder() {
return new GsonBuilder()
// build your "real" Gson builder here by registering necessary type adapters, etc...
;
}
public static void main(final String... args) {
final Gson rootGson = createDefaultRealGsonBuilder()
.registerTypeAdapter(
A.class,
gsonFactoryJsonDeserializer(
jsonElement -> jsonElement.getAsJsonObject()
.get("key")
.getAsJsonPrimitive()
.getAsInt()
,
key -> createDefaultRealGsonBuilder()
.registerTypeAdapter(B.class, (InstanceCreator<B>) type -> new B(key))
.create()
)
)
.create();
final A a = rootGson.fromJson("{\"key\":2048,\"b\":{\"x\":20,\"y\":30}}", A.class);
if ( a.key != a.b.key ) {
throw new AssertionError("NOT working!");
}
out.println("Working.");
}
输出:
工作。
请注意,我没有进行任何性能测试,不幸的是,创建新的Gson实例似乎是满足您要求的唯一方式。