java - Gson，动态InstanceCreator

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 实例的字段 key 必须与外部 A 实例的字段 key 完全相同。

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 实现类型适配器，它在提取 key 之后创建(然后用于反序列化内部 B)B_InstanceCreator？

Answer 1

Gson似乎是极度无状态的，有时候会很蛋疼。同样的故事与InstanceCreator有关上下文是通过实现此接口(interface)的对象的构造函数或 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 方法中实现了 pretty-print ):

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反序列化。然而，另一种解决方案是将真正的反序列化器嵌套到一种“影子”通用反序列化器中，从而将整个反序列化工作委托(delegate)给 Gson。这里唯一的事情是你必须记住“影子根”Gson 实例应该用于你提到的最顶层(根)的对象，否则它不会像你预期的那样工作或可能影响性能(见下面是如何获得嵌套的 Gson 实例的)。

GsonFactoryJsonDeserializer.java

让我们先快速浏览一下这个类。它本身并不进行反序列化，只是请求另一个 Gson 实例来执行反序列化。它有两个工厂方法:一个用于 JsonElement 之间的直接映射。至 Gson ，一个用于执行两个操作，例如从 JsonElement 中提取 key 并将 key 委托(delegate)给 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正在使用第二个重载:分离 key 提取和注册 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.");
}

输出:

Working.

请注意，我没有进行任何性能测试，不幸的是，创建新的 Gson 实例似乎是完成您所要求的唯一方法。