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

class A {}
class B {}

public class MainClass {
    public static void main(String[] args) throws IOException {
        String aJsonPath = "path/to/a.json";
        List<A> aList = readAJsonAsList(aJsonPath);

        String bJsonPath = "path/to/b.json";
        List<B> bList = readBJsonAsList(bJsonPath);
    }

    // 方法 for A
    private static List<A> readAJsonAsList(String jsonAFile) throws IOException {
        ObjectMapper omA = new ObjectMapper();
        List<A> aList = omA.readValue(new File(jsonAFile), new TypeReference<ArrayList<A>>() {});
        return aList;
    }

    // 方法 for B
    private static List<B> readBJsonAsList(String jsonBFile) throws IOException {
        ObjectMapper omB = new ObjectMapper();
        List<B> bList = omB.readValue(new File(jsonBFile), new TypeReference<ArrayList<B>>() {});
        return bList;
    }
}

// 尝试的泛型方法
private static <T> List<T> readJsonAsList(String jsonFile) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    // 这种方式不会生效
    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 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 <T> 列表元素的类型
     * @return 反序列化后的对象列表
     * @throws IOException 如果读取或解析JSON时发生错误
     */
    private static <T> List<T> readJsonAsList(InputStream inputStream, Class<T> 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<A> 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<B> 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<A> 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<B> 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 dummy JSON files: " + e.getMessage());
        }
    }
}