动态键值JSON的多态反序列化：使用Jackson自定义Deserializer

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

@JsonTypeInfo(
  use = JsonTypeInfo.Id.NAME, 
  include = As.PROPERTY, 
  property = "type") // 这里的 "type" 是一个固定的属性名
public static class Animal {
    public String name;
}

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

// 在抽象父类上指定自定义的反序列化器
@JsonDeserialize(using = AnimalDeserializer.class)
@JsonIgnoreProperties(ignoreUnknown = true)
public abstract class Animal {
    public String name; // 动物的名称，将从动态键中提取
}

public class Dog extends Animal {
    @JsonProperty("barkVolume") // 明确指定JSON属性名
    public int barkVolume;
}

public class Cat extends Animal {
    @JsonProperty("likesCream")
    public boolean likesCream;
    @JsonProperty("lives")
    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;
import java.util.Map;

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);

        // 遍历JSON对象的所有字段名
        Iterator<Map.Entry<String, com.fasterxml.jackson.databind.JsonNode>> fields = node.fields();
        while (fields.hasNext()) {
            Map.Entry<String, com.fasterxml.jackson.databind.JsonNode> field = fields.next();
            String fieldName = field.getKey();
            String fieldValue = field.getValue().asText(); // 获取字段的值

            // 根据字段值判断动物类型
            if ("dog".equalsIgnoreCase(fieldValue)) {
                Dog dog = mapper.treeToValue(node, Dog.class); // 将整个节点映射为Dog对象
                dog.name = fieldName; // 手动设置name属性，因为它就是动态键
                return dog;
            } else if ("cat".equalsIgnoreCase(fieldValue)) {
                Cat cat = mapper.treeToValue(node, Cat.class); // 将整个节点映射为Cat对象
                cat.name = fieldName; // 手动设置name属性
                return cat;
            }
        }
        // 如果没有匹配到任何动物类型，则抛出异常
        throw new IllegalArgumentException("无法识别的动物类型: " + node.toString());
    }
}

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来反序列化一个Animal列表
        List<Animal> animals = mapper.readValue(json, new TypeReference<List<Animal>>() {});

        animals.forEach(a -> {
            System.out.println("Name: " + a.name);
            if (a instanceof Dog) {
                System.out.println("  Type: Dog, Bark Volume: " + ((Dog) a).barkVolume);
            } else if (a instanceof Cat) {
                System.out.println("  Type: Cat, Lives: " + ((Cat) a).lives);
            }
            System.out.println("---");
        });
    }
}