jackson-databind: Deserialization wrong when using a generic class with a converter as a property

@yihtserns ,thanks a lot, ContextualDeserializer can really indeed solve the problem.

TestClassOri<Integer, String>(1, [12: "12"])
➜【TestClassConverter】
➜ TestClass<Object, Object>([1: [12: "12"]])⚠️
➜【???Serializer】
➜ {"hashMap":{"1":{"12":"12"}}}

{"hashMap":{"1":{"12":"12"}}}
➜【???Deserializer】
➜ TestClass<Object, Object>(["1": ["12": "12"]])⚠️
➜【TestClassOriConverter】
➜ TestClassOri<Object, Object>("1", ["12": "12"])💥

The illustration above is what I think happened:

1. Converters don’t have “context” about what they’re processing, they just take INPUT and convert it into OUTPUT.
2. Because of that, declaring any generic type <K> or <V> or <Whatever> on a Converter is just equivalent to declaring <Object>.

Only parameterized types are useful on a Converter, e.g. if you do this:

static class TestClassOriConverter extends StdConverter<TestClass<Integer, String>, TestClassOri<Integer, String>> {
    @Override
    public TestClassOri<Integer, String> convert(TestClass<Integer, String> value) {
        Map.Entry<Integer, HashMap<Integer, String>> entry =
                value.hashMap.entrySet().stream().findFirst().get();
        return new TestClassOri<>(entry.getKey(), entry.getValue());
    }
}

…your problem will be solved, but I think you don’t want that. You’re probably type-parameterizing TestClassOri differently in different places, e.g.

public TestClassOri<Integer, String> int2String;
public TestClassOri<Boolean, Integer> bool2Int;
public TestClassOri<String, String> string2String;

Deserializing with “context”

Warning Disclosure: Whatever I’m sharing below is what I’ve learned while playing around in my personal “just for fun” project.
I don’t have experience using them in production/real life, so I don’t know if I’m using them correctly - Jackson pros please feel free to correct any mistake, thanks.

As mentioned above, (I think) Converter API does not have any “context” of what they’re converting - they don’t have info about the “target” e.g. the target field during deserialization.

To access that information, you need to use StdDeserializer + ContextualDeserializer API:

...
@JsonDeserialize(using = TestClassOriDeserializer.class)
static class TestClassOri<T, K> {
    ...
}

static class TestClassOriDeserializer extends StdDeserializer<TestClassOri<Object, Object>> implements ContextualDeserializer {

    /**
     * For Jackson to instantiate and call {@link #createContextual(DeserializationContext, BeanProperty)}.
     */
    public TestClassOriDeserializer() {
        super(TestClassOri.class);
    }

    /**
     * Actual constructor to do work.
     */
    private TestClassOriDeserializer(JavaType targetTestClassOriType) {
        super(targetTestClassOriType);
    }

    /**
     * Get the target's (e.g. field) type info and use that to create the actual deserializer.
     */
    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext context, BeanProperty property) {
        JavaType targetTestClassOriType = context.getContextualType();

        return new TestClassOriDeserializer(targetTestClassOriType);
    }

    @Override
    public TestClassOri<Object, Object> deserialize(JsonParser parser, DeserializationContext context) throws IOException {
        JavaType targetTestClassOriType = getValueType();
        TypeBindings targetTestClassOriParameterizedTypes = targetTestClassOriType.getBindings();

        JavaType parameterizedTestClass = context.getTypeFactory().constructParametricType(TestClass.class, targetTestClassOriParameterizedTypes);
        TestClass<Object, Object> value = context.readValue(parser, parameterizedTestClass);

        Map.Entry<Object, HashMap<Object, Object>> entry =
                value.hashMap.entrySet().stream().findFirst().get();
        return new TestClassOri<>(entry.getKey(), entry.getValue());
    }
}