java 基于唯一属性的存在用Jackson反序列化多态类型

jhdbpxl9  于 2023-05-27  发布在  Java
关注(0)|答案(8)|浏览(113)

如果我有一个这样的类结构：

public abstract class Parent {
    private Long id;
    ...
}

public class SubClassA extends Parent {
    private String stringA;
    private Integer intA;
    ...
}

public class SubClassB extends Parent {
    private String stringB;
    private Integer intB;
    ...
}

是否有其他方法可以反序列化不同的@JsonTypeInfo？在我的父类上使用这个注解：

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "objectType")

我宁愿不强制API的客户端包含"objectType": "SubClassA"来反序列化Parent子类。
Jackson没有使用@JsonTypeInfo，而是提供了一种注解子类的方法，并通过唯一属性将其与其他子类区分开来吗？在我上面的例子中，这将是类似于“如果JSON对象具有"stringA": ...，则将其反序列化为SubClassA，如果它具有"stringB": ...，则将其反序列化为SubClassB”。

Java

8条答案

按热度按时间
wnrlj8wa

wnrlj8wa1#

这里有一个解决方案，我想出了一个扩展了埃里克吉莱斯皮的一点。它完全符合你的要求，对我很有效。
使用Jackson2.9

@JsonDeserialize(using = CustomDeserializer.class)
public abstract class BaseClass {

    private String commonProp;
}

// Important to override the base class' usage of CustomDeserializer which produces an infinite loop
@JsonDeserialize(using = JsonDeserializer.None.class)
public class ClassA extends BaseClass {
    
    private String classAProp;
}

@JsonDeserialize(using = JsonDeserializer.None.class)
public class ClassB extends BaseClass {
    
    private String classBProp;
}

public class CustomDeserializer extends StdDeserializer<BaseClass> {

    protected CustomDeserializer() {
        super(BaseClass.class);
    }

    @Override
    public BaseClass deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        TreeNode node = p.readValueAsTree();
        
        // Select the concrete class based on the existence of a property
        if (node.get("classAProp") != null) {
            return p.getCodec().treeToValue(node, ClassA.class);
        }
        return p.getCodec().treeToValue(node, ClassB.class);
    }
}

// Example usage
String json = ...
ObjectMapper mapper = ...
BaseClass instance = mapper.readValue(json, BaseClass.class);

如果您想更进一步，可以扩展CustomDeserializer以包含一个Map<String, Class<?>>，该Map<String, Class<?>>Map一个属性名，该属性名在出现时Map到一个特定的类。在这个article中提出了这样的方法。

更新

Jackson2.12.0获得了Polymorphic subtype deduction from available fields，增加了@JsonTypeInfo(use = DEDUCTION)！
AsDeductionTypeDeserializer实现从字段中推断子类型。作为一个POC不打算合并，有大量的剪切和粘贴代码等，但我认为一个功能性的公关将是最好的基础上讨论的东西，我写的兴趣。
它的工作原理是在注册时对每个子类型的全部可能字段进行指纹识别。在反序列化时，将可用字段与那些指纹进行比较，直到仅剩下一个候选者。它只关注直接子字段名称，因为直接子值被现有机制所覆盖，更深入的分析是一项更艰巨的ML任务，而不是Jackson的职责。
顺便说一句，这里有一个（现已关闭）Github问题请求：https://github.com/FasterXML/jackson-databind/issues/1627

赞(0）分享  回复(0）举报  2023-05-27
vawmfj5a

vawmfj5a2#

这感觉像是应该使用@JsonTypeInfo和@JsonSubTypes的东西，但是我已经通过文档挑选了，没有一个可以提供的属性似乎与您所描述的完全匹配。
您可以编写一个自定义的反序列化器，它以非标准的方式使用@JsonSubTypes的“name”和“value”属性来实现您想要的功能。反序列化器和@JsonSubTypes将在基类上提供，反序列化器将使用“name”值来检查属性的存在，如果它存在，则将JSON反序列化为“value”属性中提供的类。你的类看起来像这样：

@JsonDeserialize(using = PropertyPresentDeserializer.class)
@JsonSubTypes({
        @Type(name = "stringA", value = SubClassA.class),
        @Type(name = "stringB", value = SubClassB.class)
})
public abstract class Parent {
    private Long id;
    ...
}

public class SubClassA extends Parent {
    private String stringA;
    private Integer intA;
    ...
}

public class SubClassB extends Parent {
    private String stringB;
    private Integer intB;
    ...
}
赞(0）分享  回复(0）举报  2023-05-27
6za6bjd0

6za6bjd03#

正如其他人指出的那样，在how it should work so it hasn't been implemented上没有达成共识。
如果你有类Foo，Bar和它们的父FooBar解决方案，当你有JSON时，似乎很明显：

{
  "foo":<value>
}

或

{
  "bar":<value>
}

但是当你被一个

{
  "foo":<value>,
  "bar":<value>
}

乍一看，最后一个例子似乎是一个明显的400 Bad Request案例，但实际上有许多不同的方法：
1.处理为400 Bad Request
1.按类型/字段的优先级（例如，如果存在字段错误，则其优先级高于其他字段foo）
1.更复杂的情况2。
我目前的解决方案适用于大多数情况，并试图尽可能多地利用现有的Jackson基础设施（每个层次结构只需要1个反序列化器）：

public class PresentPropertyPolymorphicDeserializer<T> extends StdDeserializer<T> {

    private final Map<String, Class<?>> propertyNameToType;

    public PresentPropertyPolymorphicDeserializer(Class<T> vc) {
        super(vc);
        this.propertyNameToType = Arrays.stream(vc.getAnnotation(JsonSubTypes.class).value())
                                        .collect(Collectors.toMap(Type::name, Type::value,
                                                                  (a, b) -> a, LinkedHashMap::new)); // LinkedHashMap to support precedence case by definition order
    }

    @Override
    public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        ObjectMapper objectMapper = (ObjectMapper) p.getCodec();
        ObjectNode object = objectMapper.readTree(p);
        for (String propertyName : propertyNameToType.keySet()) {
            if (object.has(propertyName)) {
                return deserialize(objectMapper, propertyName, object);
            }
        }

        throw new IllegalArgumentException("could not infer to which class to deserialize " + object);
    }

    @SuppressWarnings("unchecked")
    private T deserialize(ObjectMapper objectMapper,
                          String propertyName,
                          ObjectNode object) throws IOException {
        return (T) objectMapper.treeToValue(object, propertyNameToType.get(propertyName));
    }
}

示例用法：

@JsonSubTypes({
        @JsonSubTypes.Type(value = Foo.class, name = "foo"),
        @JsonSubTypes.Type(value = Bar.class, name = "bar"),
})
interface FooBar {
}
@AllArgsConstructor(onConstructor_ = @JsonCreator)
@Value
static class Foo implements FooBar {
    private final String foo;
}
@AllArgsConstructor(onConstructor_ = @JsonCreator)
@Value
static class Bar implements FooBar {
    private final String bar;
}

Jackson构型

SimpleModule module = new SimpleModule();
module.addDeserializer(FooBar.class, new PresentPropertyPolymorphicDeserializer<>(FooBar.class));
objectMapper.registerModule(module);

如果你正在使用Sping Boot ：

@JsonComponent
public class FooBarDeserializer extends PresentPropertyPolymorphicDeserializer<FooBar> {

    public FooBarDeserializer() {
        super(FooBar.class);
    }
}

测试：

@Test
    void shouldDeserializeFoo() throws IOException {
        // given
        var json = "{\"foo\":\"foo\"}";

        // when
        var actual = objectMapper.readValue(json, FooBar.class);

        // then
        then(actual).isEqualTo(new Foo("foo"));
    }

    @Test
    void shouldDeserializeBar() throws IOException {
        // given
        var json = "{\"bar\":\"bar\"}";

        // when
        var actual = objectMapper.readValue(json, FooBar.class);

        // then
        then(actual).isEqualTo(new Bar("bar"));

    }

    @Test
    void shouldDeserializeUsingAnnotationDefinitionPrecedenceOrder() throws IOException {
        // given
        var json = "{\"bar\":\"\", \"foo\": \"foo\"}";

        // when
        var actual = objectMapper.readValue(json, FooBar.class);

        // then
        then(actual).isEqualTo(new Foo("foo"));
    }

编辑：我在这个project中添加了对这种情况的支持。

赞(0）分享  回复(0）举报  2023-05-27
2sbarzqh

2sbarzqh4#

EDIT（2021-07-15）--作废，目前状态见M. Justin's answer。

（以下为原始答案）
没有。这样的特性已经被要求了--它可以被称为“类型推断”，或者“隐含类型”--但是还没有人提出一个可行的通用建议来说明它应该如何工作。很容易想到方法来支持特定情况下的特定解决方案，但找出一般的解决方案就比较困难了。

赞(0）分享  回复(0）举报  2023-05-27
lzfw57am

lzfw57am5#

此功能已使用“deduction-based polymorphism”添加到Jackson2.12中。要将其应用于您的案例，只需使用@JsonTypeInfo(use=Id.DEDUCTION)以及@JsonSubTypes提供的支持的子类型的完整列表：

@JsonTypeInfo(use=Id.DEDUCTION)
@JsonSubTypes({@Type(SubClassA.class), @Type(SubClassB.class)})
public abstract class Parent {
    private Long id;
    ...
}

此功能是根据jackson-databind#43实现的，并在2.12发行说明中进行了总结：
它基本上允许省略实际的Type Id字段或值，只要可以从字段的存在推断出子类型（@JsonTypeInfo(use=DEDUCTION)）。也就是说，每个子类型都包含一组不同的字段，因此在反序列化期间，可以唯一且可靠地检测类型。
Jackson的创作者在Jackson 2.12 Most Wanted (1/5): Deduction-Based Polymorphism文章中给出了一个稍微长一点的解释。

赞(0）分享  回复(0）举报  2023-05-27
8iwquhpp

8iwquhpp6#

我的应用程序要求我保留旧的结构，所以我找到了一种在不更改数据的情况下支持多态性的方法。我是这么做的
1.扩展JsonDeserializer
1.转换为树并读取字段，然后返回子类对象

@Override public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    JsonNode jsonNode = p.readValueAsTree(); 
    Iterator<Map.Entry<String, JsonNode>> ite = jsonNode.fields();
    boolean isSubclass = false;
    while (ite.hasNext()) {
        Map.Entry<String, JsonNode> entry = ite.next();
        // **Check if it contains field name unique to subclass**
        if (entry.getKey().equalsIgnoreCase("Field-Unique-to-Subclass")) {
            isSubclass = true;
            break;
        }
    }
    if (isSubclass) {
        return mapper.treeToValue(jsonNode, SubClass.class);
    } else {
        // process other classes
    }
}
赞(0）分享  回复(0）举报  2023-05-27
eagi6jfj

eagi6jfj7#

处理多态要么是模型绑定的，要么需要使用各种自定义反序列化器编写大量代码。我是一个JSON Dynamic Deserialization Library的合著者，它允许模型独立的json反序列化库。OP问题的解决方案可以在下面找到。请注意，规则是以非常简短的方式声明的。

public class SOAnswer1 {

    @ToString @Getter @Setter
    @AllArgsConstructor @NoArgsConstructor
    public static abstract class Parent {
        private Long id;
    }

    @ToString(callSuper = true) @Getter @Setter
    @AllArgsConstructor @NoArgsConstructor
    public static class SubClassA extends Parent {
        private String stringA;
        private Integer intA;
    }

    @ToString(callSuper = true) @Getter @Setter
    @AllArgsConstructor @NoArgsConstructor
    public static class SubClassB extends Parent {
        private String stringB;
        private Integer intB;
    }

    public static void main(String[] args) {
        String json = "[{"
                + "    \"id\": 151243,"
                + "    \"stringA\": \"my special string\","
                + "    \"intA\": 1337"
                + "},"
                + "{"
                + "    \"id\": 734561,"
                + "    \"stringB\": \"use the Force\","
                + "    \"intB\": 451"
                + "}]";
        
        // create a deserializer instance
        DynamicObjectDeserializer deserializer = new DynamicObjectDeserializer();
        
        // runtime-configure deserialization rules
        deserializer.addRule(DeserializationRuleFactory.newRule(1, 
                (e) -> e.getJsonNode().has("stringA"),
                DeserializationActionFactory.objectToType(SubClassA.class)));
        
        deserializer.addRule(DeserializationRuleFactory.newRule(1, 
                (e) -> e.getJsonNode().has("stringB"),
                DeserializationActionFactory.objectToType(SubClassB.class)));
        
        List<Parent> deserializedObjects = deserializer.deserializeArray(json, Parent.class);
        
        for (Parent obj : deserializedObjects) {
            System.out.println("Deserialized Class: " + obj.getClass().getSimpleName()+";\t value: "+obj.toString());
        }
    }
}

输出：

Deserialized Class: SubClassA;   value: SOAnswer1.SubClassA(super=SOAnswer1.Parent(id=151243), stringA=my special string, intA=1337)
Deserialized Class: SubClassB;   value: SOAnswer1.SubClassB(super=SOAnswer1.Parent(id=734561), stringB=use the Force, intB=451)

pretius-jddl的Maven依赖关系（在maven.org/jddl上查看最新版本：

<dependency>
  <groupId>com.pretius</groupId>
  <artifactId>jddl</artifactId>
  <version>1.0.0</version>
</dependency>
赞(0）分享  回复(0）举报  2023-05-27
iq3niunx

iq3niunx8#

已经看到上面的几个答案，但我想添加我的，因为这是在生产中使用了过去2年。
我们有一个事件类型的速度，位置的车辆。
可以通过@JsonTypeInfo实现动态绑定

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY,
        property = "eventId")
@JsonSubTypes({
        @JsonSubTypes.Type(value = SpeedEvent.class, name = "10"),
        @JsonSubTypes.Type(value = LocationEvent.class, name = "11")
})
public interface EventDetails {
}
public class Event {

    private int eventId;
    private long ts;
    private EventDetails eventDetails;

    public int getEventId() {
        return eventId;
    }

    public void setEventId(int eventId) {
        this.eventId = eventId;
    }

    public long getTs() {
        return ts;
    }

    public void setTs(long ts) {
        this.ts = ts;
    }

    public EventDetails getEventDetails() {
        return eventDetails;
    }

    public void setEventDetails(EventDetails eventDetails) {
        this.eventDetails = eventDetails;
    }
}
public class SpeedEvent implements EventDetails {

    private int eventId;
    private int speed;

    public int getEventId() {
        return eventId;
    }

    public void setEventId(int eventId) {
        this.eventId = eventId;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }
}
public class LocationEvent implements EventDetails {

    private int eventId;
    private double latitude;
    private double longitude;

    public int getEventId() {
        return eventId;
    }

    public void setEventId(int eventId) {
        this.eventId = eventId;
    }

    public double getLatitude() {
        return latitude;
    }

    public void setLatitude(double latitude) {
        this.latitude = latitude;
    }

    public double getLongitude() {
        return longitude;
    }

    public void setLongitude(double longitude) {
        this.longitude = longitude;
    }
}

示例输出：-

速度事件

{
    "eventId": 10,
    "ts": 1684937053366,
    "eventDetails": {
        "eventId": "10",
        "speed": 50
    }
}

地点事件

{
    "eventId": 11,
    "ts": 1684937172450,
    "eventDetails": {
        "eventId": "11",
        "latitude": 41.40338,
        "longitude": 2.17403
    }
}
赞(0）分享  回复(0）举报  2023-05-27
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com