Problem with JsonUnwrapped and Generics in some cases

[kedar-joshi]

I am trying to create a generic deserializer for one of my projects. Problem is, when class information is provided via generics, it results in following exception -

Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "city" (class serialization.jackson.UnwrappedTest$Person), not marked as ignorable (2 known properties: "name", "address"])
 at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); line: 1, column: 43] (through reference chain: serialization.jackson.UnwrappedTest$Persons["data"]->java.util.ArrayList[0]->serialization.jackson.UnwrappedTest$Person["city"])
	at com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException.from(UnrecognizedPropertyException.java:61)
	at com.fasterxml.jackson.databind.DeserializationContext.handleUnknownProperty(DeserializationContext.java:1153)
	at com.fasterxml.jackson.databind.deser.std.StdDeserializer.handleUnknownProperty(StdDeserializer.java:2241)
	at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.handleUnknownProperty(BeanDeserializerBase.java:1821)

Any way to get this working?

import java.util.List;

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.json.JsonMapper;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.*;

public class JsonUnwrappedTests
{
	private static final Logger logger = LogManager.getLogger(JsonUnwrappedTests.class);

	private static final String json = """
			{"data":[{"name":"Thomas","city":"Zion"}]}""".strip();

	private static final JsonMapper mapper = new JsonMapper();

	@BeforeAll
	public static void initializeAll()
	{
		// mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
	}

	@Test
	void jsonUnwrappedWithConcreteClass() throws JsonProcessingException
	{
		final TypeReference<Persons<List<Person<Address>>>> singleType = new TypeReference<>() { };
		final Persons<List<Person<Address>>> persons = mapper.readValue(json, singleType);

		assertResult(persons);
	}

	@Test
	void jsonUnwrappedWithInferredClass() throws JsonProcessingException
	{
		final Persons<List<Person<Address>>> persons = JsonUnwrappedTests.getPersons(Address.class);

		assertResult(persons);
	}

	private static void assertResult(final Persons<List<Person<Address>>> persons)
	{
		logger.info("Persons: {}", persons);

		Assertions.assertNotNull(persons, "Persons is null");
		Assertions.assertNotNull(persons.getData(), "Data is null");
		Assertions.assertEquals(1, persons.getData().size(), "Size is not 1");
		Assertions.assertNotNull(persons.getData().getFirst(), "First person is null");

		final Person<Address> person = persons.getData().getFirst();

		Assertions.assertEquals("Thomas", person.getName(), "Name is null");

		Assertions.assertNotNull(person.getAddress(), "Address is null");
		Assertions.assertEquals("Zion", person.getAddress().getCity(), "City is null");

		try
		{
			Assertions.assertEquals(json, mapper.writeValueAsString(persons));
		}
		catch (JsonProcessingException e)
		{
			logger.error(e.getMessage(), e);
		}
	}

	public static <T> Persons<List<Person<T>>> getPersons(final Class<T> clazz) throws JsonProcessingException
	{
		final TypeReference<Persons<List<Person<T>>>> singleType = new TypeReference<Persons<List<Person<T>>>>() { };

		return mapper.readValue(json, singleType);
	}

	public static class Persons<T>
	{
		private T data;

		public T getData()
		{
			return this.data;
		}

		public void setData(final T data)
		{
			this.data = data;
		}

		@Override
		public String toString()
		{
			return "Persons{" + "data=" + this.data + '}';
		}
	}

	public static class Address
	{
		@JsonProperty("city")
		private String city;

		public String getCity()
		{
			return this.city;
		}

		public void setCity(final String city)
		{
			this.city = city;
		}

		@Override
		public String toString()
		{
			return "Address{" + "city='" + this.city + '\'' + '}';
		}
	}

	public static class Person<T>
	{
		private String name;

		@JsonUnwrapped
		private T address;

		public String getName()
		{
			return this.name;
		}

		public void setName(final String name)
		{
			this.name = name;
		}

		public T getAddress()
		{
			return this.address;
		}

		public void setAddress(final T address)
		{
			this.address = address;
		}

		@Override
		public String toString()
		{
			return "Person{" + "name='" + this.name + '\'' + ", address=" + this.address + '}';
		}
	}
}

[cowtowncoder]

Any chance example could be changed to a unit test? One of the most frustrating things is to have print statements with instruction of "see?". That does not explain anything about the problem or expectations.

Having said that, I think it is very likely that @JsonUnwrapped does not work with unbound T (any type potentially). Whether it can be made to work or not is not easy to say.

But one thing you should try first is what is usually the way to see how things work: start by constructing data structure, serializing, and trying to deserialize that JSON. And see if that JSON output matches your expectations. It is possible structure you have as input is not what Jackson would produce as serialization -- and the general contract is that Jackson should be able to read what it writes.

[kedar-joshi]

As suggested, sharing a project and issue examples as JUnit test cases.

json-unwrapped-generics.zip

[JooHyukKim]

Having to download a zipfile and loading on IDE probably isn't part of what we can take.
U could probably refer to how someone else did in #4834.
Very simple and yet complete enough to copy paste and run.

[kedar-joshi]

Updated according to the inputs.

[JooHyukKim]

Great, thank you! Will take a look

[JooHyukKim]

Oh and what assertion should fail?
Lets work together here. We have to really know what fails and how it fails.

Imagine its for there's someone new without any context.

[kedar-joshi]

My expectation was that jsonUnwrappedWithInferredClass should not fail but it does. But as per the response from @cowtowncoder, the reason for the failure is type erasure and is expected.

[cowtowncoder]

Oh there's a bug in test: this does not work:

final TypeReference<Persons<List<Person<T>>>> singleType = new TypeReference<Persons<List<Person<T>>>>() { };

since TypeReference cannot be used with type variables due to Java Type Erasure.

You can construct type using TypeFactory, programmatically, but usage above does not and cannot work: it is roughly same as:

Persons<List<Person<?>>>

because type variables are only used by and visible to Java compiler, not available during runtime (not included in bytecode).

Intended target type would be created using something like:

TypeFactory tf = mapper.getTypeFactory();
JavaType personType = tf.constructParametricType(Person.class, clazz);
JavaType listType = tf.constructCollectionType(List.class, personType);
JavaType personsType = tf.constructParametricType(Persons.class, listType);

(or passing actual type for TypeReference, not type variable)

[kedar-joshi]

Ah, understood. Thank you for the suggested approach, will check.

[cowtowncoder]

I hope that works better!

[kedar-joshi]

Suggested approach worked perfectly. Thank you.