泛型容器的还原序列化（延伸com.fasterxml.jackson.databind.deser.std.ReferenceTypeDeserializer）无法以这种方式登录。
您需要使用覆写findReferenceDeserializer方法来注册com.fasterxml.jackson.databind.deser.Deserializers的自订实作。这个方法会呼叫，以寻找指涉型别之值的还原序列化程式。
您还需要添加com.fasterxml.jackson.databind.type.TypeModifier，它将把“泛型容器”类型修改为com.fasterxml.jackson.databind.type.ReferenceType，这样您的自定义ReferenceTypeDeserializer将被调用。
最简单的方法是注册一个自定义的com.fasterxml.jackson.databind.Module，它将addDeserializers和addTypeModifier。一个很好的例子是Jdk8Module，它为java.util.Optional和它的朋友做所有的工作。

为自定义泛型容器MyRef注册反序列化程序的完整示例：

MyRefDeserializer。这只是一个例子。被覆盖方法的具体实现（以及需要覆盖哪些方法）将取决于您的要求。

public final class MyRefDeserializer extends ReferenceTypeDeserializer<MyRef<?>> {

    public MyRefDeserializer(JavaType fullType, ValueInstantiator vi,
            TypeDeserializer typeDeser, JsonDeserializer<?> deser) {
        super(fullType, vi, typeDeser, deser);
    }

    @Override
    protected MyRefDeserializer withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser) {
        return new MyRefDeserializer(_fullType, _valueInstantiator, typeDeser, valueDeser);
    }

    @Override
    public MyRef<?> getNullValue(DeserializationContext ctxt) throws JsonMappingException {
        return MyRef.of(_valueDeserializer.getNullValue(ctxt));
    }

    @Override
    public Object getAbsentValue(DeserializationContext ctxt) throws JsonMappingException {
        return MyRef.absent();
    }

    @Override
    public MyRef<?> referenceValue(Object contents) {
        return MyRef.of(contents);
    }

    @Override
    public Object getReferenced(MyRef<?> reference) {
        return reference.orElse(null);
    }

    @Override
    public NullableOptional<?> updateReference(MyRef<?> reference, Object contents) {
        return referenceValue(contents);
    }

}

Deserializers接口的实现：

public class MyRefDeserializers extends Deserializers.Base {

    @Override
    public JsonDeserializer<?> findReferenceDeserializer(ReferenceType refType, DeserializationConfig config,
            BeanDescription beanDesc, TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer)
            throws JsonMappingException {

        if (refType.hasRawClass(MyRef.class)) {
            return new MyRefDeserializer(refType, null, contentTypeDeserializer, contentDeserializer);
        }

        return null;
    }

}

TypeModifier的一种实现，它允许Jackson理解MyRef是一种ReferenceType类型：

public class MyRefTypeModifier extends TypeModifier {

    @Override
    public JavaType modifyType(JavaType type, Type jdkType, TypeBindings context, TypeFactory typeFactory) {
        if (type.isReferenceType() || type.isContainerType()) {
            return type;
        }

        if (type.getRawClass() == MyRef.class) {
            return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0));
        } else {
            return type;
        }

    }

}

最后是Module，它将注册反序列化器和类型修饰符：

public class MyRefModule extends Module {

    @Override
    public String getModuleName() {
        return "MyRefModule";
    }

    @Override
    public Version version() {
        return Version.unknownVersion();
    }

    @Override
    public void setupModule(SetupContext context) {
        context.addDeserializers(new MyRefDeserializers());
        context.addTypeModifier(new MyRefTypeModifier());
    }

}

然后，您需要使用ObjectMapper注册此模块。例如：

ObjectMapper = new ObjectMapper();
objectMapper.registerModule(new MyRefModule());

如果您使用Sping Boot ，则只需将模块公开为@Bean，它将自动注册为默认的ObjectMapper。

我最终为我的反序列化器实现了一个不同的接口。

class PatchableDeserializer(private val valueType: Class<*>?): JsonDeserializer<Patchable<*>>(), ContextualDeserializer {
    override fun createContextual(ctxt: DeserializationContext?, property: BeanProperty?): JsonDeserializer<*> {
        val wrapperType = property?.type

        val rawClass = wrapperType?.containedType(0)?.rawClass
        return PatchableDeserializer(rawClass)
    }

    override fun deserialize(p: JsonParser?, ctxt: DeserializationContext?): Patchable<*> =
        Patchable.of(p!!.readValueAs(valueType))

    override fun getNullValue(ctxt: DeserializationContext?): Patchable<Any> =
            if (ctxt?.parser?.currentToken == JsonToken.VALUE_NULL)
                Patchable.ofNull()
            else
                Patchable.undefined()
}

这可以正常工作，但是Jackson需要解析器中的上下文信息来使其工作，也就是说，上面的测试代码不起作用。但是，如果显式指定要反序列化到的DTO，并且该DTO具有正确的类型注解，它就可以工作。