Question

例如，有两个类

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？

Answer 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}}

V2

你知道，我有一个想法...... JsonDeserializer<A>可能不是一个需要半手动A反序列化的好主意。但是，一个替代解决方案是将一个真正的反序列化器嵌套到一种“阴影”通用反序列化器中，从而将整个反序列化作业委托给Gson。这里唯一的事情是你必须记住，“影子根”Gson实例应该用于你提到的最顶层的对象（根），否则它将无法正常工作或可能影响性能（参见如何在下面获得嵌套的Gson实例。

GsonFactoryJsonDeserializer.java

让我们先来看看这堂课。它不会自行进行反序列化，只是要求另一个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实例似乎是满足您要求的唯一方式。

Gson，动态InstanceCreator

1 个答案:

V2

GsonFactoryJsonDeserializer.java

演示