Is it expected for GSON to not serialize some data when using generics?

[WizardlyBump17]

Hello. I noticed that when I have a field with a generic type, GSON does not serialize the extra fields of the child class. If I let it raw, it works fine. Is this expected behaviour or should I open an issue?

package com.wizardlybump17.test.json;

import com.google.gson.Gson;

public class GsonNotSerializingEverything {

    public static void main(String[] args) {
        Gson gson = new Gson();

        System.out.println(gson.toJsonTree(new MyRecordNotWorking(new MyChild("aaaa", 10)))); // {"object":{"string0":"aaaa"}}
        System.out.println(gson.toJsonTree(new MyRecordWorking(new MyChild("bbbb", 20)))); // {"object":{"int0":20,"string0":"bbbb"}}
    }

    public static abstract class MyObject<T> {

        private String string0;

        public MyObject(String string0) {
            this.string0 = string0;
        }
    }

    public static class MyChild extends MyObject<Integer> {

        private int int0;

        public MyChild(String string0, int int0) {
            super(string0);
            this.int0 = int0;
        }
    }

    public record MyRecordNotWorking(MyObject<?> object) {
    }

    public record MyRecordWorking(MyObject object) {
    }
}

[lMysticl]

Yes, this is expected for the declared field type.

I ran your sample unchanged with Gson 2.12.1. The output was:

MyObject<?>  -> {"object":{"string0":"aaaa"}}
MyObject      -> {"object":{"int0":20,"string0":"bbbb"}}

MyObject<?> only gives Gson the declared generic base type. The concrete MyChild type is not preserved through that wildcard, so int0 is not part of the reflective adapter Gson uses for the field. The raw MyObject version happens to include it, but I would not use a raw type as the fix because it removes type safety.

If the field is always a MyChild, declare it as MyChild. If it really accepts multiple subclasses, use an explicit TypeAdapter/polymorphic adapter instead. Gson's guide calls out the same underlying limitation: Java type erasure loses generic type information, so the type must be supplied explicitly when it matters.

Tested with Gson 2.12.1 · Gson generic types guide

[Marcono1234]

This is due to Gson's internal TypeAdapterRuntimeTypeWrapper which for serialization only uses the type adapter for the runtime type in some cases.

So the behavior is probably intended, but might not be ideal for all use cases.

A workaround can be to have a custom TypeAdapterFactory which always uses the runtime type, see for example RuntimeTypeAdapterFactory in #1870 (comment) (the issue that comment applies to seems to be different than your use case though).
You can register this factory either for all types with a GsonBuilder, or use Gson's @JsonAdapter (as @JsonAdapter(RuntimeTypeAdapterFactory.class)) on the class MyObject or on all fields / record components of type MyObject for which you want to apply it.

Note however that if you also have to deserialize the data again, then when using the runtime type for serialization you probably also need custom deserialization logic to pick the correct MyObject subclass based on the JSON data.