无需指定类型，能否自动识别请求体中的继承子类？

在Spring Boot接口中，当请求体包含基于继承关系的对象时，使用@RequestBody如果不通过@JsonTypeInfo指定子类类型，系统无法自动识别对应的子类实例。想知道有没有不用如下硬编码子类映射的方案：

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
        @JsonSubTypes.Type(value = Fence.class, name = "fence"),
        @JsonSubTypes.Type(value = Rectangle.class, name = "rectangle"),
        @JsonSubTypes.Type(value = Point.class, name = "point"),
        @JsonSubTypes.Type(value = Circle.class, name = "circle")
})
public class Element implements Serializable {
}

尝试DEDUCTION类型推导的问题 #

我原本尝试使用JsonTypeInfo.Id#DEDUCTION自动推导子类，但当子类中存在嵌套对象时该方案失效。添加第三个子类Circle后，触发如下错误：

"JSON parse error: Could not resolve subtype of [simple type, class com.mapabc.entity.Point]: Cannot deduce unique subtype of `com.mapabc.entity.Point` (2 candidates match); nested exception is com.fasterxml.jackson.databind.exc.InvalidTypeIdException: Could not resolve subtype of [simple type, class com.mapabc.entity.Point]: Cannot deduce unique subtype of `com.mapabc.entity.Point` (2 candidates match)\n at [Source: (org.springframework.util.StreamUtils$NonClosingInputStream); line: 8, column: 9] (through reference chain: java.util.ArrayList[0]->com.moveinsync.geofencing.models.Geofence[\"geometry\"]->com.mapabc.entity.Rectangle[\"leftDown\"])

相关类定义和请求体示例如下：

Element类 #

@JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION)
@JsonSubTypes({
        @JsonSubTypes.Type(Fence.class),
        @JsonSubTypes.Type(Rectangle.class),
        @JsonSubTypes.Type(Point.class),
        @JsonSubTypes.Type(Circle.class)
})
public class Element implements Serializable {
    public CommandArgs<String, String> getCommandArgs(String key, String member){
        return null;
    }
}

Point类 #

public class Point extends Element implements Serializable {
    private double lng;
    private double lat;

    public Point() {}
    public Point(double lng, double lat) {
        this.lng = lng;
        this.lat = lat;
    }
    // getter、setter、toString省略
}

Rectangle类 #

public class Rectangle extends Element implements Serializable {
    private Point leftDown;
    private Point rightUpper;

    @Override
    public CommandArgs<String, String> getCommandArgs(String key, String member) {
        double lng1 = leftDown.getLng();
        double lat1 = leftDown.getLat();
        double lng2 = rightUpper.getLng();
        double lat2 = rightUpper.getLat();
        return new CommandArgs<>(StringCodec.UTF8).add(key).add(member).add("BOUNDS").add(lng1).add(lat1).add(lng2).add(lat2);
    }
    // 构造方法、getter、setter省略
}

Circle类 #

public class Circle extends Element implements Serializable {
    private double lng;
    private double lat;
    private int r;
}

请求体示例 #

{
    "leftDown": {
        "lng" : 4.0,
        "lat" : 1.0
    },
    "rightUpper" : {
        "lng" : 1.0,
        "lat" : 4.0
    }
}

解决方案分析 #

1. 为什么DEDUCTION会失效？ #

添加Circle类后，Jackson的类型推导逻辑发现：Point和Circle都包含lng、lat字段。解析Rectangle的leftDown字段时，JSON结构只有lng和lat，无法区分是Point还是Circle——多个候选子类匹配，导致无法确定唯一类型，最终抛出错误。

2. 无需硬编码type字段的替代方案 #

方案一：自定义Jackson类型解析器

通过自定义TypeResolverBuilder或TypeDeserializer，根据子类的唯一字段特征区分类型：

public class CustomElementTypeResolver extends StdTypeResolverBuilder {
    @Override
    public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) {
        return new CustomTypeDeserializer(baseType, subtypes);
    }

    private static class CustomTypeDeserializer extends StdTypeDeserializer {
        public CustomTypeDeserializer(JavaType baseType, Collection<NamedType> subtypes) {
            super(baseType, subtypes);
        }

        @Override
        protected JavaType _findType(DeserializationContext ctxt, JsonParser p) throws IOException {
            // 读取JSON节点，判断字段特征
            JsonNode node = p.readValueAsTree();
            if (node.has("r")) {
                return ctxt.getTypeFactory().constructType(Circle.class);
            } else if (node.has("leftDown")) {
                return ctxt.getTypeFactory().constructType(Rectangle.class);
            } else if (node.has("lng") && node.has("lat") && !node.has("r")) {
                return ctxt.getTypeFactory().constructType(Point.class);
            }
            return super._findType(ctxt, p);
        }
    }
}

在Element类上添加注解启用自定义解析器：

@JsonTypeResolver(CustomElementTypeResolver.class)
public class Element implements Serializable {
    // ...
}

方案二：调整类结构（最简洁）

如果业务允许，拆分继承关系，让Point和Circle不再继承Element，作为独立实体类：

// 独立Point类，不继承Element
public class Point implements Serializable {
    private double lng;
    private double lat;
    // ...
}

// 独立Circle类，不继承Element
public class Circle implements Serializable {
    private double lng;
    private double lat;
    private int r;
    // ...
}

// Element仅保留需要统一处理的子类（如Fence、Rectangle）
public class Element implements Serializable {
    // ...
}

这样Jackson能直接根据字段类型解析，无需额外配置，类结构也更清晰。

方案三：利用Jackson扩展增强推导

可以通过Jackson模块增强推导逻辑：

• 给Circle类添加@JsonTypeInfo(use = Id.DEDUCTION)，结合@JsonIgnoreProperties(ignoreUnknown = true)，让Jackson优先匹配字段完全匹配的子类；
• 若项目使用Kotlin，引入jackson-module-kotlin，其类型推导对字段重叠场景的处理更灵活。

3. 总结 #

• 若必须保留当前继承结构，自定义类型解析器是最优方案，能精准控制子类识别逻辑；
• 若可调整类结构，拆分独立实体类是最省心的方式，完全避免类型推导冲突；
• Jackson的DEDUCTION仅适用于子类字段完全不重叠的场景，存在字段重叠时必然失效。

内容的提问来源于stack exchange，提问作者Mukund Mundhra