Data structure that cannot be serialized properly

Below is the data structure and serialization method I defined.

@Getter
@Setter
public class Base {
	private String baseField;
	private Base child;
}

@Getter
@Setter
public class Child1 extends Base {
	private List<Integer> child1Field;
}

@Getter
@Setter
public class Child2 extends Base {
	private List<Integer> child2Field;
}

public class Test {
	public static void main(String[] args) throws JsonProcessingException {
		Base base = new Base();
		base.setBaseField("base");

		Base child1 = new Child1();
		child1.setBaseField("child1");
		List<Integer> child1Field = Lists.asList(1, new Integer[]{1});
		((Child1)child1).setChild1Field(child1Field);

		Base child2 = new Child2();
		child2.setBaseField("child2");
		List<Integer> child2Field = Lists.asList(2, new Integer[]{2});
		((Child2)child2).setChild2Field(child2Field);

		child1.setChild(child2);
		base.setChild(child1);

		System.out.println(new Gson().toJson(base));
	}
}

I thought that the result I got was like this:

{
    "baseField": "base", 
    "child": {
        "baseField": "child1", 
        "child": {
            "baseField": "child2", 
            "child2Field": [
                2, 
                2
            ]
        }, 
        "child1Field": [
            1, 
            1
        ]
    }
}

But the result I got is like this:

{
    "baseField": "base", 
    "child": {
        "baseField": "child1", 
        "child": {
            "baseField": "child2"
        }
    }
}

I lost the value of childXField. What is going on here? Is it a data type that does not support such recursive references?

[lyubomyr-shaydariv]

Not a bug, this is how Gson was designed. The reason of such design, I guess, is that you cannot restore the original Base object unless you have enough information to deserialize the object from the JSON document. You can make it work in write-only way like this:

gsonBuilder.registerTypeAdapterFactory(new TypeAdapterFactory() {
	@Override
	public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
		final Class<? super T> rawType = typeToken.getRawType();
		if ( !Base.class.isAssignableFrom(rawType) ) {
			return null;
		}
		@SuppressWarnings("unchecked")
		final TypeAdapter<T> delegateTypeAdapter = (TypeAdapter<T>) gson.getDelegateAdapter(this, TypeToken.get(rawType));
		return new TypeAdapter<T>() {
			@Override
			public void write(final JsonWriter out, final T value)
					throws IOException {
				delegateTypeAdapter.write(out, value);
			}

			@Override
			public T read(final JsonReader in) {
				throw new UnsupportedOperationException();
			}
		};
	}
})

This type adapter would write expected JSON payload. However, your DTO classes structure makes me think RuntimeTypeAdapterFactory would fit your needs.

[Marcono1234]

The underlying issue for this specific case seems to be #1833. Gson should produce the JSON data you are expecting, but due to that bug it erroneously prefers the reflective type adapter for the base type (Base) instead of the reflective type adapter for the subtype (Child1).

---

Note that I am not a member of this project.