Jackson Unmarshall custom object instead of LinkedHashMap

Question

I have a Java object Results:

public class MetaData {
    private List<AttributeValue<String,Object>> properties
    private String name
    ...

    ... getters/setters ...
}

The AttributeValue class is a generic key-value class. It's possible different AttributeValue's are nested. The (value) Object will then be another AttributeValue and so forth.

Due to legacy reasons the structure of this object cannot be altered.

I have my JSON, which I try to map to this object. All goes well for the regular properties. Also the first level of the list is filled with AttributeValues.

The problem is the Object. Jackson doesn't know how to interpret this nested behavior and just makes it a LinkedHashMap.

I'm looking for a way to implement custom behavior to tell Jackson this has to be a AttributeValue-object instead of the LinkedHashMap.

This is how I'm currently converting the JSON:

ObjectMapper om = new ObjectMapper();
MetaData metaData = om.readValue(jsonString, new TypeReference<MetaData>(){});

And this is example JSON. (this is obtained by serializing an existing MetaData object to JSON, I have complete control over this syntax).

{
    "properties":[
        {
            "attribute":"creators",
            "value":[
                {
                    "attribute":"creator",
                    "value":"user1"
                },{
                    "attribute":"creator",
                    "value":"user2"
                }
            ]
        },{
            "attribute":"type",
            "value": "question"
        }
    ],
    "name":"example"
}

(btw: I've tried the same using GSON, but then the object is a StringMap and the problem is the same. Solutions using GSON are also welcome).

edit In Using Jackson ObjectMapper with Generics to POJO instead of LinkedHashMap there is a comment from StaxMan: "LinkedHashMap is only returned when type information is missing (or if Object.class is defined as type)."

The latter seems to be the issue here. Is there a way I can override this?

Answer 1

If you have control over the serialization, try calling enableDefaultTyping() on your mapper.

Consider this example:

Pair<Integer, Pair<Integer, Integer>> pair = new Pair<>(1, new Pair<>(1, 1));
ObjectMapper mapper = new ObjectMapper();
String str = mapper.writeValueAsString(pair);
Pair result = mapper.readValue(str, Pair.class);

Without enableDefaultTyping(), I would have str = {"k":1,"v":{"k":1,"v":1}} which would deserialize to a Pair with LinkedHashMap.

But if I enableDefaultTyping() on mapper, then str = {"k":1,"v":["Pair",{"k":1,"v":1}]} which then perfectly deserializes to Pair<Integer, Pair<...>>.