Jackson与Java泛型：构建通用的JSON列表反序列化方法

private static <T> List<T> readJsonAsList(String jsonFile) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    // 这里的 TypeReference<ArrayList<T>> 在运行时 T 的信息已被擦除
    List<T> list = objectMapper.readValue(new File(jsonFile), new TypeReference<ArrayList<T>>() {});
    return list;
}

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 GenericJsonDeserializer {

    // 示例模型类 A
    private static class A {
        public String fieldA;
        // 必须提供无参构造函数和getter/setter供Jackson使用
        public A() {}
        public A(String fieldA) { this.fieldA = fieldA; }
        @Override
        public String toString() { return "A{fieldA='" + fieldA + "'}"; }
    }

    // 示例模型类 B
    private static class B {
        public int fieldB;
        // 必须提供无参构造函数和getter/setter供Jackson使用
        public B() {}
        public B(int fieldB) { this.fieldB = fieldB; }
        @Override
        public String toString() { return "B{fieldB=" + fieldB + "}"; }
    }

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

    public static void main(String[] args) {
        // 创建示例JSON文件
        createSampleJsonFiles();

        try {
            // 反序列化 List<A>
            System.out.println("Deserializing List<A> from a.json:");
            try (FileInputStream streamA = new FileInputStream("a.json")) {
                List<A> aList = readAsList(streamA, A.class);
                System.out.println(aList);
            }

            // 反序列化 List<B>
            System.out.println("\nDeserializing List<B> from b.json:");
            try (FileInputStream streamB = new FileInputStream("b.json")) {
                List<B> bList = readAsList(streamB, B.class);
                System.out.println(bList);
            }

        } catch (IOException exc) {
            exc.printStackTrace();
        } finally {
            // 清理示例JSON文件
            new File("a.json").delete();
            new File("b.json").delete();
        }
    }

    // 辅助方法：创建用于测试的JSON文件
    private static void createSampleJsonFiles() {
        ObjectMapper mapper = new ObjectMapper();
        try {
            mapper.writeValue(new File("a.json"), new ArrayList<A>() {{
                add(new A("value1"));
                add(new A("value2"));
            }});
            mapper.writeValue(new File("b.json"), new ArrayList<B>() {{
                add(new B(10));
                add(new B(20));
            }});
            System.out.println("Sample JSON files created: a.json, b.json");
        } catch (IOException e) {
            System.err.println("Error creating sample JSON files: " + e.getMessage());
        }
    }
}