Gson, dynamic InstanceCreator

Question

For example, there are two classes

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

So field key of inner B instance must be exactly as field key of outer A instance.

B's instance creator is:

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);
    }
}

How can I implement type adapter for A, which creates (and then uses to deserialize inner B) B_InstanceCreator just after extracting key?

Answer 1

Gson seems to be extremely stateless, and it hurts sometimes. The same story is relevant to InstanceCreator where the context is passed via a constructor or setters of an object implementing this interface like you menitoned above. Obtaining the key is only possible when deserializing the A class since the classes of the child nodes are not aware of its parent object context. So you have to implement a deserializer for the A class first (unfortunately losing annotations like @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();
    }

}

As you can see above, its another performance-weak place is createInnerGson that instantiates a Gson builder, an instance creator, and finally the inner Gson instance behind the scenes (don't know how much it costs). But it seems to be the only way to pass the key context to the instance creator. (It would be nice if Gson could implement a fromJson method to overwrite the state of a B instance (say, something like gson.merge(someJson, someBInstance)) -- but Gson can only produce new deserialized values.)

The JSON deserializer can be used as follows (assuming A and B have pretty-print implemented in their respective toString methods):

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);

Output:

2048, 2048
A{key=2048, b=B{key=2048, x=20, y=30}}

---

V2

You know, I have an idea... JsonDeserializer<A> probably was not that a good idea requiring semi-manual A deserializing. However, an alternatve solution is nesting a real deserializer into a sort of a "shadow" generic deserializer, thus delegating the whole deserialiation job to Gson. The only thing here is that you have to remember that "shadow root" Gson instances should be used for the objects you mentioned as top-most (the root), otherwise it won't work as you might expect or might affect performance (see how nested Gson instances are obtained below).

GsonFactoryJsonDeserializer.java

Let's first take a quick look on this class. It does not make deserialization itself and just asks for another Gson instance to perform deserialization. It has two factory methods: one for direct mapping between JsonElement to Gson, and one for having two operations like extracting a key from JsonElement and delegating the key to the Gson factory (remember the specifics of InstanceCreator discussed above?). This deserializer actually does nothing more than just obtaining the root JSON element.

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);
    }

}

Demo

The demo below encapsulates a GsonBuilder factory method in order to create a new GsonBuilder instance on demand because Gson builders are stateful and using the same instance may leed to pretty unexpected behavior. gsonFactoryJsonDeserializer is using the second overload: to separate key extraction and registering the B class instantiator. If the keys in outer and inner objects does not match (a.key must equal a.b.key), the application should throw an assertion error that should never happen in production.

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.");
}

Output:

Working.

Note that I didn't make any performance testing, and unfortunately creating new Gson instances seems to be the only way of doing what you were asking for.