Why GSON fails to convert Object when it's a field of another Object?

Question

GSON fails to convert Errorneous to JSON properly when it's inside of other Object.

But it works well when it's converted as a top level object. Why, and how to fix it?

Example:

import com.google.gson.GsonBuilder

sealed class Errorneous<R> {}
data class Success<R>(val result: R) : Errorneous<R>()
data class Fail<R>(val error: String) : Errorneous<R>()

class Container(val value: Errorneous<String>)

fun main() {
  print(GsonBuilder().create().toJson(Container(Fail("some error"))))

  print(GsonBuilder().create().toJson(Fail<String>("some error")))
}

Output

{"value":{}}

{"error":"some error"}

But it should be

{"value":{"error":"some error"}}

{"error":"some error"}

This happens because Gson cannot resolve the actual subtype on the given `` that is unknown at runtime for the `Container` class scope. What you can do here is either removing `` from the `Errorneous` class (that makes sense), or try to propagate the `` parameter to the `Container` class and use type token (it doesn't seem to work though; a Gson bug?). — terrorrussia-keeps-killing, Jan 27 '21 at 13:09
I guess the reason of the behavior is the way Gson resolves actual types. Registering a type adapter factory can produce the following output when serializing `Container` instances: `Container`, `Errorneous` -- it does not resolve the last one as a `Fail` (because field type is not accessible for type adapter factories, hence it merely cannot do `.getClass()` on the value), + plus it _looks like_ `Success` to Gson. The core issue is that Gson does not know which class it should use. — terrorrussia-keeps-killing, Jan 27 '21 at 13:13
@Mafor thanks for link, but I don't like the answers from that question, the accepted answer suggest to use `List — Alex Craft, Jan 27 '21 at 18:32
@AlexCraft As far as I understand, Gson v2.1 supports polymorphic collections, which is sth a bit different. This answer should work in your case: https://stackoverflow.com/a/15016251/9090751 — Mafor, Jan 27 '21 at 18:38

score 1 · Answer 1 · answered Jan 27 '21 at 13:33

I made some comments regarding Gson behavior right under the post (in short: not enough runtime type information), so this is only code to make it work and make it actual type-aware.

private static final Gson gson = new GsonBuilder()
        .registerTypeAdapterFactory(new TypeAdapterFactory() {
            @Override
            @Nullable
            public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
                final Class<? super T> rawType = typeToken.getRawType();
                if ( rawType != Errorneous.class ) {
                    return null;
                }
                final ParameterizedType parameterizedType = (ParameterizedType) typeToken.getType();
                @SuppressWarnings("unchecked")
                final TypeToken<Success<?>> successTypeToken = (TypeToken<Success<?>>) TypeToken.getParameterized(Success.class, parameterizedType.getActualTypeArguments());
                @SuppressWarnings("unchecked")
                final TypeToken<Fail<?>> failTypeToken = (TypeToken<Fail<?>>) TypeToken.getParameterized(Fail.class, parameterizedType.getActualTypeArguments());
                final TypeAdapter<Success<?>> successTypeAdapter = gson.getDelegateAdapter(this, successTypeToken);
                final TypeAdapter<Fail<?>> failTypeAdapter = gson.getDelegateAdapter(this, failTypeToken);
                final TypeAdapter<Errorneous<?>> concreteTypeAdapter = new TypeAdapter<Errorneous<?>>() {
                    @Override
                    public void write(final JsonWriter out, final Errorneous<?> value)
                            throws IOException {
                        if ( value instanceof Success ) {
                            final Success<?> success = (Success<?>) value;
                            successTypeAdapter.write(out, success);
                            return;
                        }
                        if ( value instanceof Fail ) {
                            final Fail<?> fail = (Fail<?>) value;
                            failTypeAdapter.write(out, fail);
                            return;
                        }
                        throw new AssertionError(); // even null cannot get here: it is protected with .nullSafe() below
                    }

                    @Override
                    public Errorneous<?> read(final JsonReader in) {
                        throw new UnsupportedOperationException();
                    }
                };
                @SuppressWarnings("unchecked")
                final TypeAdapter<T> typeAdapter = ((TypeAdapter<T>) concreteTypeAdapter)
                        .nullSafe();
                return typeAdapter;
            }
        })
        .create();

@AllArgsConstructor
@SuppressWarnings("unused")
private abstract static class Errorneous<R> {
}

@AllArgsConstructor
@SuppressWarnings("unused")
private static final class Success<R>
        extends Errorneous<R> {

    private final R result;

}

@AllArgsConstructor
@SuppressWarnings("unused")
private static final class Fail<R>
        extends Errorneous<R> {

    private final String error;

}

@AllArgsConstructor
@SuppressWarnings("unused")
private static class Container {

    private final Errorneous<String> value;

}

public static void main(final String... args) {
    System.out.println(gson.toJson(new Container(new Fail<>("some error"))));
    System.out.println(gson.toJson(new Fail<>("some error")));
}

As you can see, the type adapter factory first resolves type adapters for both Success and Fail, and then picks a proper one based on the actual class of the Errorneous value with instanceof ().

Here is what it prints:

{"value":{"error":"some error"}}
{"error":"some error"}

The deserialization is made an unsupported operation since it must decide how the JSON can be deserialized: 1) either on a type designator field (see RuntimeTypeAdapterFactory in Gson extras in their repository on GitHub; it's not bundled and published as an artifact); 2) or analyze the structure of the object making heuristics analysis (much harder to implement and may face with ambiguous cases).

I don't do Kotlin, but the Java code above can be probably easily converted to its Kotlin counterpart right in IntelliJ IDEA.

Thank you for taking time and writing the solution code! It's not good that you have to write JSON mapping code manually, but there's probably no better way... — Alex Craft, Jan 27 '21 at 18:33
@AlexCraft Unfortunately, type adapter factories accept only the declaration site type via type tokens, so the actual runtime type should be resolved in other way (e.g. manually). I guess that the Gson authors decided not to include it by default because of several issues, one of which I mentioned above and suppressed with an unsupported operation exception stub (no easy way to deserialize). It's only a guess, as they also mention that non static anonymous classes cannot serialized because of a similar reason (no way to deserialize its inner `this`). — terrorrussia-keeps-killing, Jan 27 '21 at 18:39

score 0 · Answer 2 · answered Jan 27 '21 at 19:07

Answer in Kotlin copied from the similar Java Question

import com.google.gson.GsonBuilder
import com.google.gson.JsonElement
import com.google.gson.JsonSerializationContext
import com.google.gson.JsonSerializer
import java.lang.reflect.Type

sealed class Errorneous<R> {}
data class Success<R>(val result: R) : Errorneous<R>()
data class Fail<R>(val error: String) : Errorneous<R>()

class Container(
  val value: Errorneous<String>
 )

fun main() {
  val builder = GsonBuilder()
  builder.registerTypeAdapter(
    Errorneous::class.java, ErrorneousSerializer()
  )
  val gson = builder.create()
  print(gson.toJson(Container(Fail("some error"))))
  print(gson.toJson(Fail<String>("some error")))
}

class ErrorneousSerializer : JsonSerializer<Errorneous<Any>> {
  override fun serialize(
    o: Errorneous<Any>, type: Type, ctx: JsonSerializationContext
  ): JsonElement {
    return ctx.serialize(o as Any)
  }
}

It may be a suboptimal solution since it uses in-memory JSON trees rather than JSON token streaming. — terrorrussia-keeps-killing, Jan 27 '21 at 20:29

Why GSON fails to convert Object when it's a field of another Object?

2 Answers2

Linked