Jackson自定义反序列化实现动态类型键的JSON多态处理

{
  "bulli": "dog",
  "barkVolume": 10
}
{
  "kitty": "cat",
  "likesCream": true,
  "lives": 3
}

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

// 抽象基类 Animal，指定自定义反序列化器
@JsonDeserialize(using = AnimalDeserializer.class)
@JsonIgnoreProperties(ignoreUnknown = true) // 忽略JSON中未映射的字段
public abstract class Animal {
    public String name; // 动物的名称，将由动态键提供
}

// Dog 类
public class Dog extends Animal {
    @JsonProperty
    public int barkVolume;
}

// Cat 类
public class Cat extends Animal {
    @JsonProperty
    public boolean likesCream;
    @JsonProperty
    public int lives;
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.IOException;
import java.util.Iterator;

public class AnimalDeserializer extends JsonDeserializer<Animal> {

    @Override
    public Animal deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        // 获取 ObjectMapper 实例，用于后续的节点到对象转换
        ObjectMapper mapper = (ObjectMapper) jsonParser.getCodec();
        // 将当前JSON节点读取为 ObjectNode，以便遍历其字段
        ObjectNode node = mapper.readTree(jsonParser);

        // 遍历 ObjectNode 中的所有字段名
        Iterator<String> fieldIterator = node.fieldNames();
        while (fieldIterator.hasNext()) {
            String fieldName = fieldIterator.next();
            // 检查当前字段的值是否为 "dog" (不区分大小写)
            if (node.get(fieldName).asText().equalsIgnoreCase("dog")) {
                // 如果是 "dog"，则将整个节点映射到 Dog 类
                Dog dog = mapper.treeToValue(node, Dog.class);
                // 将识别出的动态键作为动物的名称
                dog.name = fieldName;
                return dog;
            } 
            // 检查当前字段的值是否为 "cat" (不区分大小写)
            else if (node.get(fieldName).asText().equalsIgnoreCase("cat")) {
                // 如果是 "cat"，则将整个节点映射到 Cat 类
                Cat cat = mapper.treeToValue(node, Cat.class);
                // 将识别出的动态键作为动物的名称
                cat.name = fieldName;
                return cat;
            }
        }
        // 如果遍历完所有字段仍未识别出动物类型，则抛出异常
        throw new IllegalArgumentException("无法识别的动物类型");
    }
}

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

public class Farm {

    private static final String json = "[" +
            "{\"bulli\":\"dog\",\"barkVolume\":10},\n" +
            "{\"dogi\":\"dog\", \"barkVolume\":7},\n" +
            "{\"kitty\":\"cat\", \"likesCream\":true, \"lives\":3},\n" +
            "{\"milkey\":\"cat\", \"likesCream\":false, \"lives\":9}" +
            "]";

    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        // 使用 TypeReference 反序列化为 List<Animal>
        List<Animal> animals = mapper.readValue(json, new TypeReference<List<Animal>>() {});

        // 遍历并打印反序列化后的动物信息
        animals.forEach(a -> {
            System.out.println("动物名称: " + a.name);
            if (a instanceof Dog) {
                Dog dog = (Dog) a;
                System.out.println("  类型: 狗, 叫声大小: " + dog.barkVolume);
            } else if (a instanceof Cat) {
                Cat cat = (Cat) a;
                System.out.println("  类型: 猫, 是否喜欢奶油: " + cat.likesCream + ", 生命数: " + cat.lives);
            }
            System.out.println("---");
        });
    }
}

动物名称: bulli
  类型: 狗, 叫声大小: 10
---
动物名称: dogi
  类型: 狗, 叫声大小: 7
---
动物名称: kitty
  类型: 猫, 是否喜欢奶油: true, 生命数: 3
---
动物名称: milkey
  类型: 猫, 是否喜欢奶油: false, 生命数: 9
---