使用Jackson TypeFactory实现Java泛型列表反序列化

解决方案：利用Jackson TypeFactory动态构建类型

要解决类型擦除问题，我们需要在运行时向Jackson提供泛型类型T的具体Class对象。Jackson提供了TypeFactory类，用于在运行时动态构建JavaType。TypeFactory.constructCollectionType()方法能够将集合类型和元素类型结合起来，形成一个完整的类型描述。

具体步骤如下：

1. 传入元素类型： 修改泛型方法，使其接受一个Class类型的参数，该参数代表列表中元素的具体类型。
2. 使用TypeFactory构建JavaType： 通过TypeFactory.defaultInstance().constructCollectionType(collectionClass, elementClass)方法，传入集合类型（例如List.class）和元素的Class对象，动态构建出完整的JavaType。

此外，为了增强方法的通用性，建议将文件路径参数替换为InputStream。这样，该方法不仅可以处理文件，还可以处理网络流、内存中的字节数组流等多种输入源。

下面是经过优化的泛型反序列化方法：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.ArrayList;

public class GenericJacksonDeserializer {

    // 示例模型类
    private static class A {
        public String name;
        public int id;

        // 默认构造函数是Jackson反序列化所必需的
        public A() {} 

        public A(String name, int id) {
            this.name = name;
            this.id = id;
        }

        @Override
        public String toString() {
            return "A{name='" + name + "', id=" + id + "}";
        }
    }

    private static class B {
        public String description;
        public double value;

        // 默认构造函数
        public B() {}

        public B(String description, double value) {
            this.description = description;
            this.value = value;
        }

        @Override
        public String toString() {
            return "B{description='" + description + "', value=" + value + "}";
        }
    }

    /**
     * 通用的JSON列表反序列化方法
     *
     * @param inputStream 包含JSON数据的输入流
     * @param elementType 列表中元素的Class对象
     * @param  列表元素的类型
     * @return 反序列化后的对象列表
     * @throws IOException 如果读取或解析JSON时发生错误
     */
    private static  List readJsonAsList(InputStream inputStream, Class elementType) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        TypeFactory factory = TypeFactory.defaultInstance();
        // 动态构建JavaType，指定集合类型为List.class，元素类型为elementType
        return mapper.readValue(inputStream, factory.constructCollectionType(List.class, elementType));
    }

    public static void main(String[] args) {
        // 假设我们有以下JSON文件
        // a.json: [{"name":"Item A1","id":1},{"name":"Item A2","id":2}]
        // b.json: [{"description":"Desc B1","value":10.5},{"description":"Desc B2","value":20.0}]

        // 为了示例，我们先创建模拟的JSON文件
        createDummyJsonFiles();

        try (InputStream aStream = new FileInputStream("a.json")) {
            List aList = readJsonAsList(aStream, A.class);
            System.out.println("Deserialized A List: " + aList);
        } catch (IOException exc) {
            System.err.println("Error reading A list: " + exc.getMessage());
            exc.printStackTrace();
        }

        try (InputStream bStream = new FileInputStream("b.json")) {
            List bList = readJsonAsList(bStream, B.class);
            System.out.println("Deserialized B List: " + bList);
        } catch (IOException exc) {
            System.err.println("Error reading B list: " + exc.getMessage());
            exc.printStackTrace();
        }
    }

    // 辅助方法：创建模拟的JSON文件
    private static void createDummyJsonFiles() {
        ObjectMapper mapper = new ObjectMapper();
        try {
            List dummyAList = new ArrayList<>();
            dummyAList.add(new A("Item A1", 1));
            dummyAList.add(new A("Item A2", 2));
            mapper.writeValue(new File("a.json"), dummyAList);

            List dummyBList = new ArrayList<>();
            dummyBList.add(new B("Desc B1", 10.5));
            dummyBList.add(new B("Desc B2", 20.0));
            mapper.writeValue(new File("b.json"), dummyBList);

            System.out.println("Dummy JSON files created: a.json, b.json");
        } catch (IOException e) {
            System.err.println("Failed to create du
mmy JSON files: " + e.getMessage());
        }
    }
}

注意事项与总结