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;

// 在父类上指定使用自定义反序列化器
@JsonDeserialize(using = AnimalDeserializer.class)
@JsonIgnoreProperties(ignoreUnknown = true) // 忽略JSON中未知字段，提高健壮性
public abstract class Animal {
    public String name; // 存储动态键名作为对象的名称
}

@JsonDeserialize // 子类也需要反序列化，但具体逻辑由父类的Deserializer处理
public class Dog extends Animal {
    @JsonProperty
    public int barkVolume;
}

@JsonDeserialize
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实例，用于将JSON节点转换为Java对象
        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; // 将动态键名设置为对象的name属性
                return dog;
            } 
            // 检查当前字段的值是否为"cat"（忽略大小写）
            else if (node.get(fieldName).asText().equalsIgnoreCase("cat")) {
                // 如果是"cat"，则将整个节点反序列化为Cat对象
                Cat cat = mapper.treeToValue(node, Cat.class);
                cat.name = fieldName; // 将动态键名设置为对象的name属性
                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) {
                System.out.println("  叫声音量: " + ((Dog) a).barkVolume);
            } else if (a instanceof Cat) {
                System.out.println("  生命数: " + ((Cat) a).lives);
            }
            System.out.println("---");
        });
    }
}