Gson,动态InstanceCreator

时间:2017-01-04 19:28:41

标签: java json gson json-deserialization

例如,有两个类

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?

1 个答案:

答案 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反序列化器可以如下使用(假设AB在各自的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实例执行反序列化。它有两种工厂方法:一种用于JsonElementGson之间的直接映射,另一种用于执行两项操作,例如从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实例似乎是满足您要求的唯一方式。