Jackson泛型反序列化：构建通用的List数据读取方法

本教程旨在解决java中jackson库泛型反序列化`list`的常见挑战。我们将探讨直接使用`typereference>`在泛型方法中的局限性，并详细演示如何通过`typefactory.constructcollectiontype`结合运行时传入元素类型`class`来构建一个真正通用的数据读取方法，同时建议使用`inputstream`提升方法的通用性。

构建通用的Jackson泛型列表反序列化方法

在Java应用开发中，我们经常需要将JSON数据反序列化为特定类型的对象列表。当面对多种不同类型的列表（例如 List 和 List) 时，编写多个重复的反序列化方法显然不符合DRY（Don't Repeat Yourself）原则。一个自然的想法是创建一个泛型方法，例如 List readJsonAsList(String jsonFile)，以实现代码复用。然而，直接在泛型方法中使用 new TypeReference>() {} 往往无法奏效，这涉及到Java的类型擦除机制以及Jackson库对运行时类型信息的依赖。

理解泛型方法与类型擦除的挑战

Java泛型在编译时进行类型检查，但在运行时，泛型类型参数（如 T）会被擦除，替换为它们的上界（通常是 Object）。这意味着在运行时，new TypeReference>() {} 实际上变成了 new TypeReference>() {}，Jackson无法从中获取到 T 的具体类型信息，从而导致反序列化失败或得到不期望的结果。

为了让Jackson能够正确地将JSON数组反序列化为 List，我们需要在运行时明确告知它 T 的实际类型。

解决方案：利用Jackson的TypeFactory

Jackson库提供了 TypeFactory 类，专门用于在运行时构建复杂的Java类型。通过 TypeFactory，我们可以动态地构造出包含泛型参数的 JavaType 对象，然后将其传递给 ObjectMapper 的 readValue 方法。

核心步骤如下：

1. 传入元素类型： 泛型方法需要额外接收一个 Class 参数，用于指定列表中元素的具体类型。
2. 构建集合类型： 使用 TypeFactory.defaultInstance().constructCollectionType(List.class, elementType) 方法来构建一个表示 List 的 JavaType。其中，List.class 指定了集合的类型，elementType (即传入的 Class) 指定了集合元素的类型。

下面是实现这一通用方法的代码示例：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.io.FileInputStream; // 用于文件输入流示例
import java.io.ByteArrayInputStream; // 用于字符串输入流示例
import java.nio.charset.StandardCharsets;

public class GenericJsonListDeserializer {

    // 示例模型类 A
    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 + '}';
        }
    }

    // 示例模型类 B
    static class B {
        public String code;
        public boolean active;

        public B() {}
        public B(String code, boolean active) { this.code = code; this.active = active; }

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

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

    public static void main(String[] args) {
        // 模拟JSON数据
        String aJsonContent = "[{\"name\":\"ItemA1\",\"id\":1},{\"name\":\"ItemA2\",\"id\":2}]";
        String bJsonContent = "[{\"code\":\"CODE_B1\",\"active\":true},{\"code\":\"CODE_B2\",\"active\":false}]";

        // 示例使用：从字符串内容反序列化
        try (InputStream aStream = new ByteArrayInputStream(aJsonContent.getBytes(StandardCharsets.UTF_8))) {
            List aList = readJsonAsList(aStream, A.class);
            System.out.println("Deserialized A List from String: " + aList);
        } catch (IOException exc) {
            System.err.println("Error reading A list from Stri
ng: " + exc.getMessage());
        }

        try (InputStream bStream = new ByteArrayInputStream(bJsonContent.getBytes(StandardCharsets.UTF_8))) {
            List bList = readJsonAsList(bStream, B.class);
            System.out.println("Deserialized B List from String: " + bList);
        } catch (IOException exc) {
            System.err.println("Error reading B list from String: " + exc.getMessage());
        }

        // 示例使用：从文件反序列化 (假设文件存在并包含上述JSON内容)
        // 请替换为实际文件路径，例如 "src/main/resources/a.json"
        String aJsonFilePath = "path/to/a.json"; 
        String bJsonFilePath = "path/to/b.json"; 

        // 为了让示例可运行，这里创建临时文件
        // try {
        //     java.nio.file.Files.write(java.nio.file.Paths.get(aJsonFilePath), aJsonContent.getBytes(StandardCharsets.UTF_8));
        //     java.nio.file.Files.write(java.nio.file.Paths.get(bJsonFilePath), bJsonContent.getBytes(StandardCharsets.UTF_8));
        // } catch (IOException e) {
        //     System.err.println("Failed to create temp files: " + e.getMessage());
        // }

        // try (InputStream aFileStream = new FileInputStream(aJsonFilePath)) {
        //     List aListFromFile = readJsonAsList(aFileStream, A.class);
        //     System.out.println("Deserialized A List from File: " + aListFromFile);
        // } catch (IOException exc) {
        //     System.err.println("Error reading A list from file: " + exc.getMessage());
        // }

        // try (InputStream bFileStream = new FileInputStream(bJsonFilePath)) {
        //     List bListFromFile = readJsonAsList(bFileStream, B.class);
        //     System.out.println("Deserialized B List from File: " + bListFromFile);
        // } catch (IOException exc) {
        //     System.err.println("Error reading B list from file: " + exc.getMessage());
        // }
    }
}

提升方法通用性：使用InputStream