如何设计Java Entity POJO以兼容已知与未知JSON键值对？

需要设计Java类存储以下JSON消息的反序列化结果：

{
    "appId": "MyApp",
    "action": "Upsert",
    "entityType": "Property",
    "entity": {
        "marketId":   "abc123",
        "propertyId": "def456",
        "name":       "Grand Central Station",
        "hasFoo":     true,
        "hasBar":     false,
        "areaInSf":   30000
        // 更多未知键值对
    }
}

需求要点：

• entity节点内的marketId、propertyId、name为必填字段，需做强类型校验（如ID最小长度）
• 需兼容entity内任意数量的未知额外字段，且能遍历这些字段
• 拒绝直接使用Map<String, Object>，要求用强类型Entity类

Jackson提供了专门处理未知字段的注解，既能保留强类型的必填字段，又能自动收集所有未匹配的额外字段，完美满足需求。

1. 定义强类型Entity类（带校验） #

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import java.util.HashMap;
import java.util.Map;

public class Entity {
    // 必填字段，添加校验规则
    @NotBlank(message = "marketId不能为空")
    @Size(min = 6, message = "marketId长度不能小于6位")
    private String marketId;

    @NotBlank(message = "propertyId不能为空")
    @Size(min = 6, message = "propertyId长度不能小于6位")
    private String propertyId;

    @NotBlank(message = "name不能为空")
    private String name;

    // 存储所有未知额外字段的Map
    private final Map<String, Object> additionalFields = new HashMap<>();

    // 接收所有未匹配到类中声明字段的键值对
    @JsonAnySetter
    public void setAdditionalField(String key, Object value) {
        additionalFields.put(key, value);
    }

    // 序列化时将额外字段输出为同级节点（可选，若不需要序列化可省略）
    @JsonAnyGetter
    public Map<String, Object> getAdditionalFields() {
        return additionalFields;
    }

    // 常规getter/setter（必填字段的）
    public String getMarketId() { return marketId; }
    public void setMarketId(String marketId) { this.marketId = marketId; }

    public String getPropertyId() { return propertyId; }
    public void setPropertyId(String propertyId) { this.propertyId = propertyId; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

2. 定义顶层Message类 #

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

// 忽略顶层可能存在的未知字段（可选，根据需求调整）
@JsonIgnoreProperties(ignoreUnknown = true)
public class Message {
    private String appId;
    private String action;
    private String entityType;
    private Entity entity;

    // 常规getter/setter
    public String getAppId() { return appId; }
    public void setAppId(String appId) { this.appId = appId; }

    public String getAction() { return action; }
    public void setAction(String action) { this.action = action; }

    public String getEntityType() { return entityType; }
    public void setEntityType(String entityType) { this.entityType = entityType; }

    public Entity getEntity() { return entity; }
    public void setEntity(Entity entity) { this.entity = entity; }
}

3. 反序列化与校验示例 #

import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        String json = "{\"appId\":\"MyApp\",\"action\":\"Upsert\",\"entityType\":\"Property\",\"entity\":{\"marketId\":\"abc123\",\"propertyId\":\"def456\",\"name\":\"Grand Central Station\",\"hasFoo\":true,\"hasBar\":false,\"areaInSf\":30000}}";

        // 反序列化JSON到Java对象
        ObjectMapper objectMapper = new ObjectMapper();
        Message message = objectMapper.readValue(json, Message.class);

        // 校验Entity的必填字段
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
        validator.validate(message.getEntity()).forEach(violation -> {
            System.out.println("校验失败：" + violation.getPropertyPath() + " " + violation.getMessage());
        });

        // 遍历未知额外字段
        message.getEntity().getAdditionalFields().forEach((key, value) -> {
            System.out.println("额外字段：" + key + " = " + value);
        });
    }
}

关键说明 #

• @JsonAnySetter：Jackson反序列化时，所有未匹配到类中声明字段的键值对，都会自动调用这个方法存入additionalFieldsMap
• @JsonAnyGetter：序列化时，会把additionalFields中的键值对作为同级节点输出（如果不需要序列化回JSON，可以省略这个注解）
• 校验规则：使用JSR-380（Jakarta Validation）注解实现必填、长度等校验，确保强类型的约束
• 灵活性：additionalFieldsMap可以存储任意类型的未知字段值，Jackson会自动转换对应类型（如布尔值、数字等）

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