杰克逊反序列化多种类型 [英] Jackson deserialization on multiple types

问题描述

我有一个名为 Instance 的抽象类，然后是它的两个实现，UserInstance 和 HardwareInstance.我遇到的问题是，当我将 @POST 的其余端点调用到数据库中时，我理想地希望它像 .../rest/soexample/instance/create 实例被传递到 REST 端点的位置.如果 Instance 不是具有多个实现的抽象，那就没问题了，但是由于我有 2 个，所以我收到了 Jackson.databind 错误.

I have an abstract class called Instance and then two implementations of that, UserInstance and HardwareInstance. The issue I am having is that when I call the rest endpoint for a @POST into the database, I ideally wanted it to be like .../rest/soexample/instance/create where the instance is passed to the REST endpoint. If Instance wasn't abstract with more than one implementation it would be fine, but since I have 2 I am getting a Jackson.databind error.

"问题:抽象类型要么需要映射到具体类型，要么需要自定义反序列化器，要么使用附加类型信息进行实例化"

在查找解决方案后，我找到了一个 SO 答案，说我可以使用以下内容:

After looking up a solution to this I found a SO answer that said I could use something like:

@JsonDeserialize(as=UserInstance.class)

但似乎只有在抽象类的一种实现时才有用.假设我不能调用它两次，因为它无法决定它是哪种类型的实例.

But it seem's like that isonly useful if there is one implementation of the abstract class. Assuming I can't call it twice since there would be no way for it to decide which type of instance it would be.

所以我想知道处理这种情况的最佳方法是什么?我应该创建不同的端点吗?喜欢:

So I am wondering what is the best way to handle this situation? Should I create different endpoints? Like:

.../rest/soexample/userinstance/create &.../rest/soexample/hardwareinstance/create

我不太确定，因为我是一个 noobie @ REST 相关的东西，虽然积极尝试学习.谢谢！

I am not too sure as I am a noobie @ REST related things, though actively trying to learn. Thanks!

推荐答案

这是我在您的同一案例中所做的:

Here is what I did in your same case:

@JsonDeserialize(using = InstanceDeserializer.class)
public abstract class Instance {
    //.. methods
}

@JsonDeserialize(as = UserInstance.class)
public class UserInstance extends Instance {
    //.. methods
}

@JsonDeserialize(as = HardwareInstance.class)
public class HardwareInstance extends Instance {
    //.. methods
}

public class InstanceDeserializer extends JsonDeserializer<Instance> {
    @Override
    public Instance deserialize(JsonParser jp,  DeserializationContext ctxt) throws IOException, JsonProcessingException {
        ObjectMapper mapper = (ObjectMapper) jp.getCodec();
        ObjectNode root = (ObjectNode) mapper.readTree(jp);
        Class<? extends Instance> instanceClass = null;
        if(checkConditionsForUserInstance()) {
            instanceClass = UserInstance.class;
        } else { 
            instanceClass = HardwareInstance.class;
        }   
        if (instanceClass == null){
            return null;
        }
        return mapper.readValue(root, instanceClass );
    }
}

您使用 @JsonDeserialize(using = InstanceDeserializer.class) 注释 Instance 以指示用于反序列化抽象类的类.然后，您需要指出每个子类将自己反序列化 as，否则它们将使用父类反序列化器，您将得到 StackOverflowError.

You annotate Instance with @JsonDeserialize(using = InstanceDeserializer.class) to indicate the class to be used to deserialize the abstract class. You need then to indicate that each child class will be deserialized as themselves, otherwise they will use the parent class deserializer and you will get a StackOverflowError.

最后，在 InstanceDeserializer 中，您将反序列化的逻辑放入一个或另一个子类(例如 checkConditionsForUserInstance()).

Finally, inside the InstanceDeserializer you put the logic to deserialize into one or another child class (checkConditionsForUserInstance() for example).

这篇关于杰克逊反序列化多种类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！