Java Jackson自定义反序列化-can'；不要读取JsonParser两次

我正在尝试实现一个Jackson反序列化程序，以便在JSON发生变化时能够进行迁移（例如，像重命名的字段，在这里我需要将现在不一致的JSON读入一致的JSON）

一种方法是创建一个JsonDeserializer，将JSON作为正确的最终类读取，然后将其作为映射再次读取，以选择更改

但我似乎无法做到这一点，因为每次我读取或反序列化JSON时，支持流都会关闭

class CustomDeserializer extends StdDeserializer<MyPOJO> implements ResolvableDeserializer{

    private final JsonDeserializer<?> deserializer;
    private final ObjectMapper mapper;

    public CustomDeserializer(JsonDeserializer<?> deserializer, ObjectMapper mapper) {
        super(MyPOJO.class);
        this.deserializer = deserializer;
        this.mapper = mapper;
    }

    @Override
    public MyPOJO deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        MyPOJO deserialized = (MyPOJO) deserializer.deserialize(jp, ctxt);
        // Custom migration would go here...
        return deserialized;
    }

    @Override
    public void resolve(DeserializationContext ctxt) throws JsonMappingException {
        ((ResolvableDeserializer) deserializer).resolve(ctxt);
    }
}

类CustomDeserializer扩展StdDeserializer实现ResolvableDeserializer{
私有最终JsonDeserializer反序列化程序；
私有最终对象映射器映射器；
公共自定义反序列化程序（JsonDeserializer反序列化程序、ObjectMapper映射程序）{
超级（MyPOJO.class）；
this.deserializer=反序列化器；
this.mapper=mapper；
}
@凌驾
公共MyPOJO反序列化（JsonParser jp，DeserializationContext ctxt）抛出IOException，JsonProcessingException{
MyPOJO反序列化=（MyPOJO）反序列化器；
//自定义迁移将转到此处。。。
返回反序列化；
}
@凌驾
public void resolve（反序列化上下文ctxt）引发JsonMappingException{
（（ResolvableDeserializer）反序列化器）.resolve（ctxt）；
}
}

---

我避免创建新的ObjectMapper，因为已经有一个自定义的ObjectMapper，例如带有自定义日期反序列化器，所以当我使用MyPOJO自定义反序列化器时，我希望能够以某种方式委托反序列化，以便它使用所有以前的配置。

这就是我想到的：

@Autowired
    public Serializer(List<IDeserializer> deserializers) {
        SimpleModule module = new SimpleModule("name");
        registerDeserializers(module, deserializers);
        mapper.registerModule(module);
        mapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
    }

    private void registerDeserializers(SimpleModule module, List<IDeserializer> deserializers) {
        if (CollectionUtils.isNotEmpty(deserializers)) {
            final Map<Class<?>, IDeserializer> deserializerRegistryMap = toMap(deserializers);
            module.setDeserializerModifier(new BeanDeserializerModifier() {
                @Override
                public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
                    if (deserializerRegistryMap.containsKey(beanDesc.getBeanClass())){
                        return deserializerRegistryMap.get(beanDesc.getBeanClass()).getDeserializer(mapper);
                    }
                    return super.modifyDeserializer(config, beanDesc, deserializer);
                }
            });
        }
    }


@Component
public class MigrationDeserializer {

    @Autowired
    private MigratorRegistry migratorRegistry;

    public <T> JsonDeserializer<T> createDeserializer(final ObjectMapper mapper, final Class<T> returnType, final Class<? extends SerializedObjectsHistory<T>> historyType){
       return new StdDeserializer<T>(returnType){

           @Override
           public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
               SerializedObjectsHistory<T> history = mapper.readValue(p, historyType);
               return migratorRegistry.migrate(history, returnType);
           }
       };
    }
}

@Autowired
公共序列化程序（列表反序列化程序）{
SimpleModule=新的SimpleModule（“名称”）；
寄存器序列化器（模块、反序列化器）；
映射器注册表模块（模块）；
configure（反序列化功能。使用大小数表示浮点数，true）；
setSerializationInclusion（JsonInclude.Include.NON_NULL）；
setDateFormat（新的SimpleDateFormat（“yyyy-MM-dd”）；
}
专用无效注册表项序列化程序（SimpleModule模块、列表反序列化程序）{
if（CollectionUtils.isNotEmpty（反序列化程序））{
最终地图