jackson反序列化时被默认转换为LinkedHashMap的问题

AI提问：

有 1个类 A：
class A {
private Object b;
private Object c;
private int x;
}

另有类 B和类 C：
class B {
private Object o1;
private String field1;
private String field2;
}

class C {
private Object o1;
private int field1;
private int field2;
}

今有 1个 A的实例：
A a = new A();
a.b = new B();
a.c = new C();

并使用 jackson 库将对象 a序列化为 json 。

现在想将这段 json 反序列化为 a对象，并且，a.b 必须是 B类型的，a.c 必须是 C类型的。

需要注意的是，B 类型和 C类型希望在程序运行时动态指定，不要硬编码。

请用 java 写代码示例实现以上功能。

 

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;

import java.io.IOException;

// 定义 A类型，b 和c 都是 Object 类型
class A {
    @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class")
    private Object b;
    
    @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property = "@class")
    private Object c;
    
    private int x;

    public A() {}

    public A(Object b, Object c, int x) {
        this.b = b;
        this.c = c;
        this.x = x;
    }

    public Object getB() {
        return b;
    }

    public void setB(Object b) {
        this.b = b;
    }

    public Object getC() {
        return c;
    }

    public void setC(Object c) {
        this.c = c;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
}

// 定义 B类型
class B {
    private Object o1;
    private String field1;
    private String field2;

    public B() {}

    public B(Object o1, String field1, String field2) {
        this.o1 = o1;
        this.field1 = field1;
        this.field2 = field2;
    }

    public Object getO1() {
        return o1;
    }

    public void setO1(Object o1) {
        this.o1 = o1;
    }

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }
}

// 定义 C类型
class C {
    private Object o1;
    private int field1;
    private int field2;

    public C() {}

    public C(Object o1, int field1, int field2) {
        this.o1 = o1;
        this.field1 = field1;
        this.field2 = field2;
    }

    public Object getO1() {
        return o1;
    }

    public void setO1(Object o1) {
        this.o1 = o1;
    }

    public int getField1() {
        return field1;
    }

    public void setField1(int field1) {
        this.field1 = field1;
    }

    public int getField2() {
        return field2;
    }

    public void setField2(int field2) {
        this.field2 = field2;
    }
}

public class Main {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        // 创建 A对象，b 属性是 B类型，c 属性是 C类型
        A originalA = new A(new B(null, "field1Value", "field2Value"), new C(null, 123, 456), 10);

        // 序列化 A对象
        String json = objectMapper.writeValueAsString(originalA);
        System.out.println("Serialized JSON: " + json);

        // 反序列化回 A对象
        A deserializedA = objectMapper.readValue(json, A.class);

        // 检查 b属性
        if (deserializedA.getB() instanceof B) {
            B b = (B) deserializedA.getB();
            System.out.println("Deserialized A.b type: " + b.getClass().getName() + ", field1: " + b.getField1() + ", field2: " + b.getField2());
        }

        // 检查 c属性
        if (deserializedA.getC() instanceof C) {
            C c = (C) deserializedA.getC();
            System.out.println("Deserialized A.c type: " + c.getClass().getName() + ", field1: " + c.getField1() + ", field2: " + c.getField2());
        }
    }
}

 

代码说明

1. @JsonTypeInfo 注解：在类 A 的 b 和 c 字段上使用 @JsonTypeInfo 注解，指定使用类名作为类型标识。这将使 Jackson 在序列化时将类型信息嵌入到 JSON 中，并在反序列化时使用这些信息来确定具体的类型。

2. 序列化和反序列化：使用 ObjectMapper 序列化和反序列化对象 A。由于类型信息被包含在 JSON 中，Jackson 能够正确地反序列化 b 和 c 字段到它们的具体类型 B 和 C。

通过这种方式，可以在程序运行时动态指定类型，而无需对类型进行硬编码。