无类型信息时Jackson多态反序列化配置问题求助

你遇到的核心问题是：只给接口添加了@JsonSubTypes，但没有告诉Jackson如何根据JSON中的foo/bar属性来推断具体要实例化哪个子类。Jackson默认需要明确的类型标识来选择子类，而你的场景是通过子类独有的属性区分，所以需要补充类型推断的配置。

下面是两种可行的解决方案，优先推荐第一种（Jackson 2.12+版本支持）：

方案一：使用属性自动推导（Jackson 2.12+） #

Jackson 2.12新增了DEDUCTION类型推断方式，它会根据JSON中存在的独有属性自动匹配对应的子类——只要Y和Z的独有属性（foo/bar）没有重叠，就能正确识别。

修改后完整代码如下：

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import java.util.Map;

@JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION) // 关键：开启属性推导
@JsonSubTypes({
    @JsonSubTypes.Type(Y.class),
    @JsonSubTypes.Type(Z.class)
})
interface X {
    @JsonProperty("extraInfo") // 确保Jackson能识别这个属性
    Map<String, Object> getExtraInfo();
}

@Getter
class Y implements X {
    private final String foo;
    private Map<String, Object> extraInfo; // 补充字段并通过@Getter暴露

    public Y(@JsonProperty("foo") String foo) {
        this.foo = foo;
    }
}

@Getter
class Z implements X {
    private final String bar;
    private Map<String, Object> extraInfo; // 补充字段并通过@Getter暴露

    public Z(@JsonProperty("bar") String bar) {
        this.bar = bar;
    }
}

注意事项： #

• 确保你的Jackson版本≥2.12，DEDUCTION是这个版本才引入的特性；
• 接口X中的extraInfo需要通过getter或@JsonProperty暴露，否则Jackson无法处理该字段；
• 子类的独有属性（foo/bar）不能交叉存在（比如JSON同时有foo和bar会导致歧义），这种情况需要额外处理。

方案二：自定义类型鉴别器（兼容低版本Jackson） #

如果你的Jackson版本低于2.12，可以自定义一个类型鉴别器，通过检查JSON中是否存在foo或bar来选择子类：

import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.jsontype.TypeIdResolver;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder;
import com.fasterxml.jackson.databind.type.JavaType;
import java.util.Collection;

// 自定义类型鉴别逻辑
class XTypeResolverBuilder extends StdTypeResolverBuilder {
    @Override
    public TypeIdResolver buildTypeIdResolver(DeserializationContext ctxt, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) {
        return new XTypeIdResolver(baseType);
    }

    private static class XTypeIdResolver extends TypeIdResolverBase {
        protected XTypeIdResolver(JavaType baseType) {
            super(baseType, null);
        }

        @Override
        public String idFromValue(Object value) {
            return value instanceof Y ? "y" : "z";
        }

        @Override
        public String idFromValueAndType(Object value, Class<?> suggestedType) {
            return idFromValue(value);
        }

        @Override
        public JavaType typeFromId(DeserializationContext ctxt, String id) {
            return id.equals("y") ? ctxt.getTypeFactory().constructType(Y.class) : ctxt.getTypeFactory().constructType(Z.class);
        }

        @Override
        public JsonTypeInfo.Id getMechanism() {
            return JsonTypeInfo.Id.CUSTOM;
        }

        // 关键：从JSON节点判断类型
        @Override
        public String idFromNode(JsonNode node, DeserializationContext ctxt) {
            if (node.has("foo")) {
                return "y";
            } else if (node.has("bar")) {
                return "z";
            }
            throw new IllegalArgumentException("无法识别的子类类型");
        }
    }
}

然后在接口X上配置这个自定义鉴别器：

@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM, typeResolver = XTypeResolverBuilder.class)
@JsonSubTypes({
    @JsonSubTypes.Type(Y.class),
    @JsonSubTypes.Type(Z.class)
})
interface X {
    @JsonProperty("extraInfo")
    Map<String, Object> getExtraInfo();
}

这种方式兼容性更好，但代码量更大，适合无法升级Jackson版本的场景。

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