如何用Jackson ObjectMapper从嵌套JSON中反序列化目标对象

针对JSON结构不固定、外层可能存在重名字段的场景，我们可以通过先解析为JsonNode遍历查找或自定义反序列化器两种方式定位到包含必填字段的目标对象，再完成反序列化。

方案一：解析为JsonNode后递归查找目标节点 #

先将JSON解析为Jackson的JsonNode，递归遍历所有节点，找到包含name、age、color三个必填字段的节点，再反序列化为Dog对象。

代码实现 #

首先定义Dog类（保留@JsonIgnoreProperties避免未知字段报错）：

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Dog {
    private String name;
    private int age;
    private String color;

    // 生成getter、setter和无参构造方法
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
}

然后编写工具方法，递归查找目标节点：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;

public class JsonParsingUtil {
    private static final List<String> REQUIRED_FIELDS = Arrays.asList("name", "age", "color");
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static Dog extractDogFromJson(String json) throws Exception {
        JsonNode rootNode = objectMapper.readTree(json);
        JsonNode targetNode = findTargetNode(rootNode);
        if (targetNode == null) {
            throw new IllegalArgumentException("JSON中未找到包含所有必填字段的Dog对象");
        }
        return objectMapper.treeToValue(targetNode, Dog.class);
    }

    private static JsonNode findTargetNode(JsonNode node) {
        // 检查当前节点是否包含所有必填字段
        boolean hasAllRequired = REQUIRED_FIELDS.stream().allMatch(node::has);
        if (hasAllRequired) {
            return node;
        }

        // 递归遍历子节点
        if (node.isObject()) {
            for (JsonNode childNode : node) {
                JsonNode result = findTargetNode(childNode);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
}

使用示例 #

public class Main {
    public static void main(String[] args) throws Exception {
        // 测试第一种JSON结构
        String json1 = "{\"type\":\"animal\",\"name\":\"pet\",\"object\":{\"name\":\"Rex\",\"age\":4,\"color\":\"brown\"}}";
        Dog dog1 = JsonParsingUtil.extractDogFromJson(json1);
        System.out.println(dog1.getName()); // 输出Rex

        // 测试第二种JSON结构
        String json2 = "{\"pet-dog\":{\"name\":\"Rex\",\"age\":4,\"color\":\"brown\"}}";
        Dog dog2 = JsonParsingUtil.extractDogFromJson(json2);
        System.out.println(dog2.getColor()); // 输出brown
    }
}

方案二：自定义Dog类的反序列化器 #

通过实现Jackson的JsonDeserializer，在反序列化逻辑中直接查找目标节点，无需手动解析JsonNode。

代码实现 #

自定义反序列化器：

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class DogDeserializer extends JsonDeserializer<Dog> {
    private static final List<String> REQUIRED_FIELDS = Arrays.asList("name", "age", "color");

    @Override
    public Dog deserialize(JsonParser parser, DeserializationContext context) throws IOException {
        JsonNode rootNode = parser.getCodec().readTree(parser);
        JsonNode targetNode = findTargetNode(rootNode);
        if (targetNode == null) {
            throw new IOException("未找到符合要求的Dog对象");
        }
        return parser.getCodec().treeToValue(targetNode, Dog.class);
    }

    private JsonNode findTargetNode(JsonNode node) {
        if (REQUIRED_FIELDS.stream().allMatch(node::has)) {
            return node;
        }
        if (node.isObject()) {
            for (JsonNode child : node) {
                JsonNode result = findTargetNode(child);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
}

在Dog类上注册反序列化器：

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

@JsonIgnoreProperties(ignoreUnknown = true)
@JsonDeserialize(using = DogDeserializer.class)
public class Dog {
    // 字段、getter、setter、构造方法同方案一
}

使用示例 #

直接用ObjectMapper反序列化即可：

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = "{\"type\":\"animal\",\"name\":\"pet\",\"object\":{\"name\":\"Rex\",\"age\":4,\"color\":\"brown\"}}";
        Dog dog = objectMapper.readValue(json, Dog.class);
        System.out.println(dog.getAge()); // 输出4
    }
}

说明 #

• @JsonProperty(required=true)仅适用于固定字段名的场景，无法处理结构多变的JSON，因此不适用当前需求。
• 两种方案均通过检查必填字段来定位目标节点，能有效避免外层重名字段的干扰（外层节点缺少age或color字段，不会被误判为目标）。

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