杰克逊对多种类型的反序列化 [英] 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 );
    }
}

您注释实例 with @JsonDeserialize（using = InstanceDeserializer.class）表示用于反序列化抽象类的类。然后，您需要指示每个子类将被反序列化为本身，否则它们将使用父类反序列化器，您将获得 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 中，您将逻辑反序列化为一个或另一个孩子class（ checkConditionsForUserInstance（）例如）。

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

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