Java Jackson JsonDeserializer将字段的反序列化委托回该字段类型的默认反序列化程序

给定

我在Jackson中有以下序列化程序：

public class ConstraintMatch {
    protected String constraintName;
    protected Score score;
    ...
}

公共类ConstraintMacHjacksonJSONSerializer扩展JsonSerializer{
@凌驾
公共void序列化（ConstraintMatch ConstraintMatch、JsonGenerator生成器、SerializerProvider序列化器）
抛出IOException{
generator.writeStartObject（）；
generator.writeStringField（“constraintName”，constraintMatch.getConstraintName（））；
generator.writeFieldName（“分数”）；
//将序列化委托给默认分数序列化程序
serializers.findValueSerializer（Score.class）
.serialize（constraintMatch.getScore（），生成器，序列化程序）；
generator.writeEndObject（）；
}
}

如何编写同时委托给默认反序列化程序的反序列化程序

public class ConstraintMatchJacksonJsonSerializer extends JsonSerializer<ConstraintMatch> {

    @Override
    public void serialize(ConstraintMatch constraintMatch, JsonGenerator generator, SerializerProvider serializers)
            throws IOException {
        generator.writeStartObject();
        generator.writeStringField("constraintName", constraintMatch.getConstraintName());
        generator.writeFieldName("score");
        // Delegate to serialization to the default Score serializer
        serializers.findValueSerializer(Score.class)
                 .serialize(constraintMatch.getScore(), generator, serializers);
        generator.writeEndObject();
    }

}

公共类ConstraintMacHjacksonJSondeSerializer扩展JsonDeserializer{
@凌驾
公共约束匹配反序列化（JsonParser解析器，反序列化上下文）引发IOException{
JsonNode tree=parser.readValueAsTree（）；
字符串constraintName=tree.get（“constraintName”）.asText（）；
JsonNode scoreNode=tree.get（“score”）；
Score=…；//如何委托给默认的反序列化程序？
返回新的ConstraintMatch（constraintName，score）；
}
}

---

我已经查看了

FindContextalValueDeserializer（）

等，但我无法创建

BeanProperty

实例。

在类似的情况下，我实际上发现有两个问题需要解决。首先，正如您所说，需要委托回正常的反序列化程序。但我遇到的另一个问题是如何将JsonNode（下面的TreeNode）馈送到下一个反序列化（JsonParser，…）中

下面是这种情况下的一个工作示例，我想做一个前瞻性的工作来找出子类

希望这里的节点是您的scoreNode。听起来objectClass就是为您准备的Score.class

public class ConstraintMatchJacksonJsonDeserializer extends JsonDeserializer<ConstraintMatch> {

    @Override
    public ConstraintMatch deserialize(JsonParser parser, DeserializationContext context) throws IOException {
        JsonNode tree = parser.readValueAsTree();

        String constraintName = tree.get("constraintName").asText();

        JsonNode scoreNode = tree.get("score");
        Score score = ...; // How do I delegate to the default deserializer?
        return new ConstraintMatch(constraintName, score);
    }

}

@覆盖
公共T反序列化（JsonParser解析器，反序列化上下文ctxt）
抛出IOException、JsonProcessingException{
ObjectMapper映射器=（ObjectMapper）parser.getCodec（）；
TreeNode=parser.readValueAsTree（）；
//选择要反序列化为的子类
类序列化此：

@Override
public T deserialize(JsonParser parser, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    ObjectMapper mapper = (ObjectMapper) parser.getCodec();
    TreeNode node = parser.readValueAsTree();

    // Select the subclass to deserialize as
    Class<? extends T> objectClass = deduceClass(node);

    // This based on ObjectMapper._convert()
    // - the problem here was the JsonParser (parser) had gone past the current node
    TokenBuffer buf = new TokenBuffer(mapper, false);
    SerializationConfig config = mapper.getSerializationConfig()
            .without(SerializationFeature.WRAP_ROOT_VALUE);
    DefaultSerializerProvider serializerProvider = ((DefaultSerializerProvider) mapper
            .getSerializerProvider()).createInstance(config,
                    mapper.getSerializerFactory());
    serializerProvider.serializeValue(buf, node);
    JsonParser nestedParser = buf.asParser();
    nestedParser.nextToken();
    JsonDeserializer<Object> deserializer = ctxt
            .findRootValueDeserializer(
                    mapper.getTypeFactory().constructType(objectClass));
    @SuppressWarnings("unchecked")
    T obj = (T) deserializer.deserialize(nestedParser, ctxt);

    return obj;

}

constraintMatch.getConstraintPackage（））；
generator.writeStringField（“constraintName”，constraintMatch.getConstraintName（））；
generator.writeFieldName（“分数”）；
//委托给多态性CoreJacksonJSonSerializer
JsonSerializer scoreSerializer=serializers.findValueSerializer（Score.class）；
serialize（constraintMatch.getScore（），生成器，序列化程序）；
generator.writeEndObject（）；

可以使用以下命令反序列化：

    constraintMatch.getConstraintPackage());
    generator.writeStringField("constraintName", constraintMatch.getConstraintName());

    generator.writeFieldName("score");
    // Delegate to PolymorphicScoreJacksonJsonSerializer
    JsonSerializer<Object> scoreSerializer = serializers.findValueSerializer(Score.class);
    scoreSerializer.serialize(constraintMatch.getScore(), generator, serializers);
    generator.writeEndObject();

parser.nextToken（）；
if（！“constraintName”.equals（parser.getCurrentName（）））{
抛出新的非法状态异常（…）；
}
parser.nextToken（）；
字符串constraintName=parser.getValueAsString（）；
parser.nextToken（）；
if（！“score”.equals（parser.getCurrentName（）））{
抛出新的非法状态异常（…）；
}
parser.nextToken（）；
JsonDeserializer scoreDeserializer=context.findnonContextalValueDeserializer（context.constructType（Score.class））；
Score=（Score）scoreDeserializer.反序列化（解析器，上下文）；
很有趣，但我找到了一种方法，但没有使用readValueAsTree（），因此我可以传入原始解析器。请参阅我的其他答案。
    parser.nextToken();
    if (!"constraintName".equals(parser.getCurrentName())) {
        throw new IllegalStateException(...);
    }
    parser.nextToken();
    String constraintName = parser.getValueAsString();

    parser.nextToken();
    if (!"score".equals(parser.getCurrentName())) {
        throw new IllegalStateException(...);
    }
    parser.nextToken();
    JsonDeserializer<Object> scoreDeserializer = context.findNonContextualValueDeserializer(context.constructType(Score.class));
    Score score = (Score) scoreDeserializer.deserialize(parser, context);