Ignore unregistered subtypes in RuntimeTypeAdapterFactory

user_3131147 0
Viewed 903

We have a Retrofit API using GSON as the converter, and it makes a call for a list of cards to display to the user. A card follows this format:

[
    {
        "cardType": "user",
        "data": {}
    },
    {
        "cardType": "content",
        "data": {}
    }
]

The data property varies between cards, so to resolve this we use GSON's RuntimeTypeAdapterFactory: 

final RuntimeTypeAdapterFactory<Card> factory = RuntimeTypeAdapterFactory
        .of(Card.class, "cardType")
        .registerSubtype(UserCard.class, "user")
        ...
        .registerSubtype(ContentCard.class, "content");

However, we've found that if the API is updated to include a new cardType that we aren't expecting, this silently fails to deserialize. By silently I mean, response.isSuccessful() still returns true, but the response.body() is null. The only way we were able to determine the new card type was the problem was through trial and error.

Is there any way to have GSON ignore any cardTypes that we haven't registered? If we try to add this new card but the app can't support it I would like to just ignore it.

retrofit gson android json java
2 Answers

I think that the problem is due the fact that RuntimeTypeAdapterFactory will throw an exception when trying to create adapter for unregistered type name (see excerpt from RuntimeTypeAdapterFactorys source code):

public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) {
    ...

    // typeFieldName is the type name that is given when registering the sub type
    if (jsonObject.has(typeFieldName)) {
        throw new JsonParseException("cannot serialize " + srcType.getName()
            + " because it already defines a field named " + typeFieldName);
    }

    ...
}

This might lead Retrofit to truncate the whole response to null.

Then see the declaration of TypeAdapterFactory:

public interface TypeAdapterFactory {
    /**
    * Returns a type adapter for {@code type}, or null if this factory doesn't
    * support {@code type}.
    */
    <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type);
}

If you were able to return null instead of throwing that exception I guess Retrofit could return all the sub classes it recognises.

This would be easy to handle by extending RuntimeTypeAdapterFactory and overriding the problematic method but unfortunately class is declared as final.

So you can either create a wrapping type adapter that calls the original RuntimeTypeAdapter inside it or as I would do it just copy the source for the class RuntimeTypeAdapterFactory in to some package of your own and edit it correspoding your needs. It is Open Source. So the problematic part would be like:

if (jsonObject.has(typeFieldName)) {
    log.warn("cannot serialize " + srcType.getName()
            + " because it already defines a field named " + typeFieldName);
    return null;
}

To clarify, because you are now returning null instead of throwing, your list will contain this null element. To truly ignore it, make sure you call list.filterNotNull() at the implementation.

user_64133770

We had a similar problem but GSON wasn't so silent. We were hitting the error:

cannot deserialize X subtype named Y; did you forget to register a subtype?

To implement @pirho 's solution we copied RuntimeTypeAdapterFactory into our project.

1.) add a new field

private final Map<String, Class<?>> labelToSubtype = new LinkedHashMap<String, Class<?>>();
private final Map<Class<?>, String> subtypeToLabel = new LinkedHashMap<Class<?>, String>();
private final List<String> labelsToIgnore = new ArrayList<>(); // ADD THIS LINE

2.) add a new method:

public RuntimeTypeAdapterFactory<T> ignoreSubtype(String label) {
    labelsToIgnore.add(label);
    return this;
}

3.) update the read method in the TypeAdapter:

public R read(final JsonReader in) {
    JsonElement jsonElement = Streams.parse(in);
    JsonElement labelJsonElement = jsonElement.getAsJsonObject().remove(typeFieldName);
    if (labelJsonElement == null) {
        throw new JsonParseException("cannot deserialize " + baseType
                + " because it does not define a field named " + typeFieldName);
    }
    String label = labelJsonElement.getAsString();
    @SuppressWarnings("unchecked") // registration requires that subtype extends T
            TypeAdapter<R> delegate = (TypeAdapter<R>) labelToDelegate.get(label);
    if (delegate == null) {
        // ------------- ADD THIS:
        if (labelsToIgnore.contains(label)) {
            return null;
        } else {
            throw new JsonParseException("cannot deserialize " + baseType + " subtype named "
                    + label + "; did you forget to register a subtype?");
        }
        // -------------
    }
    return delegate.fromJsonTree(jsonElement);
}

Finally use it like:

RuntimeTypeAdapterFactory<BaseClass> myTypeAdapterFactory 
= RuntimeTypeAdapterFactory
                .of(BaseClass.class, "type")
                .ignoreSubtype("type to ignore") // ADD THIS LINE
                .registerSubtype(SubtypeA.class, "type_a")
                .registerSubtype(SubtypeB.class, "type_b");          
                ...
user_16506740
Related