java – Gson,动态InstanceCreator

2019年7月28日 199次阅读

例如,有两个类

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？

最佳答案 Gson似乎非常无国籍,有时会伤害.相同的故事与InstanceCreator相关,其中上下文通过构造函数或实现此接口的对象的setter传递,就像您上面提到的那样.只有在反序列化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实例(不知道它的成本是多少).但它似乎是将关键上下文传递给实例创建者的唯一方法. (如果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.");
}

输出：

Working.

请注意,我没有进行任何性能测试,不幸的是,创建新的Gson实例似乎是满足您要求的唯一方式.

点赞