这个问题我之前也碰到过！Jackson的@JsonTypeInfo注解里的property参数并不支持嵌套的属性路径（像metadata.eventName这种用点分隔的层级路径），它会直接在EventPayload的根层级去找名为metadata.eventName的字段，自然找不到，所以才抛出了那个"missing property"的错误。

下面给你两种可行的解决方案，你可以根据自己的场景选择：

方案一：用@JsonCreator手动处理类型判断 #

这种方法逻辑最直接，不需要复杂的注解配置，在EventPayload的构造函数里手动根据metadata.eventName的值来反序列化event字段：

public class EventPayload<T> {
    private Metadata metadata;
    private T event;

    // 用@JsonCreator标记构造函数，让Jackson用它来实例化对象
    @JsonCreator
    public EventPayload(
            @JsonProperty("metadata") Metadata metadata,
            @JsonProperty("event") JsonNode eventNode) throws IOException {
        this.metadata = metadata;
        ObjectMapper mapper = new ObjectMapper();
        // 根据eventName选择对应的类型反序列化
        switch (metadata.getEventName()) {
            case "FooEvent":
                this.event = (T) mapper.treeToValue(eventNode, FooEvent.class);
                break;
            case "BarEvent":
                this.event = (T) mapper.treeToValue(eventNode, BarEvent.class);
                break;
            default:
                throw new IllegalArgumentException("Unsupported event type: " + metadata.getEventName());
        }
    }

    // 别忘了添加getter和setter
    public Metadata getMetadata() { return metadata; }
    public void setMetadata(Metadata metadata) { this.metadata = metadata; }
    public T getEvent() { return event; }
    public void setEvent(T event) { this.event = event; }
}

这个方法的好处是逻辑清晰、容易调试，适合事件类型不多的场景。

方案二：自定义TypeIdResolver实现嵌套属性的类型识别 #

如果你的事件类型比较多，或者想更贴合Jackson的原生多态序列化机制，可以自定义一个TypeIdResolver来手动读取嵌套的eventName：

第一步：实现自定义的TypeIdResolver

import com.fasterxml.jackson.databind.DatabindContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeIdResolver;
import com.fasterxml.jackson.databind.type.TypeFactory;

public class NestedEventTypeIdResolver implements TypeIdResolver {
    private JavaType baseType;

    @Override
    public void init(JavaType baseType) {
        this.baseType = baseType;
    }

    @Override
    public String idFromValue(Object value) {
        // 序列化时使用，这里我们主要处理反序列化，返回对应eventName即可
        if (value instanceof EventPayload<?>) {
            return ((EventPayload<?>) value).getMetadata().getEventName();
        }
        return null;
    }

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

    @Override
    public String idFromBaseType() {
        return idFromValue(null);
    }

    @Override
    public JavaType typeFromId(DatabindContext context, String id) {
        // 根据eventName返回对应的泛型类型
        Class<?> eventClass = switch (id) {
            case "FooEvent" -> FooEvent.class;
            case "BarEvent" -> BarEvent.class;
            default -> throw new IllegalArgumentException("Unknown event type: " + id);
        };
        return context.getTypeFactory().constructParametricType(EventPayload.class, eventClass);
    }

    @Override
    public JavaType typeFromId(DatabindContext context, String id, TypeFactory typeFactory) {
        return typeFromId(context, id);
    }

    @Override
    public TypeResolverBuilder<?> typeResolverBuilder() {
        return null;
    }

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

第二步：在EventPayload上配置自定义的TypeIdResolver

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.annotation.JsonTypeIdResolver;

@JsonTypeInfo(
        use = JsonTypeInfo.Id.CUSTOM,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        visible = true,
        property = "metadata" // 指定metadata作为触发类型解析的属性
)
@JsonTypeIdResolver(NestedEventTypeIdResolver.class)
public class EventPayload<T> {
    private Metadata metadata;
    private T event;

    // 构造函数、getter、setter
    public EventPayload() {}

    public EventPayload(Metadata metadata, T event) {
        this.metadata = metadata;
        this.event = event;
    }

    // getter和setter
    public Metadata getMetadata() { return metadata; }
    public void setMetadata(Metadata metadata) { this.metadata = metadata; }
    public T getEvent() { return event; }
    public void setEvent(T event) { this.event = event; }
}

这种方法更符合Jackson的原生多态处理逻辑，适合类型较多、需要统一管理的场景。

另外还要提醒你：你的错误日志里的JSON是"content": { ... }，但你的类里是private T event;，这两个字段名要对应上！要么把JSON里的content改成event，要么在event字段上加上@JsonProperty("content")注解，不然Jackson也会找不到对应字段哦。

内容的提问来源于stack exchange，提问作者Marcin Kłopotek