Jackson反序列化：处理JSON数组到嵌套List的Java对象映射

本文深入探讨了在使用jackson库将json数组反序列化为包含嵌套列表的java对象时常见的`mismatchedinputexception`问题。文章详细分析了json结构与pojo定义不匹配的原因，并提供了三种解决方案：直接解析为列表、调整json结构，以及通过自定义反序列化器实现灵活映射，旨在帮助开发者高效解决此类序列化挑战。

在Java开发中，我们经常需要将JSON字符串转换为Java对象（POJO）。Jackson是一个流行的JSON处理库，提供了强大的序列化和反序列化功能。然而，当JSON结构与目标POJO的预期结构不完全匹配时，可能会遇到MismatchedInputException等错误。本文将详细解析一个常见场景：将一个直接由对象数组组成的JSON字符串反序列化到一个包含嵌套列表的POJO中，并提供多种解决方案。

理解JSON与POJO结构不匹配的问题

假设我们有一个JSON字符串，它是一个对象数组，每个对象包含name、number和age字段：

[
    {
        "name": "A",
        "number": 1,
        "age": 20
    },
    {
        "name": "B",
        "number": 2,
        "age": 30
    },
    {
        "name": "C",
        "number": 3,
        "age": 40
    }
]

我们期望将其反序列化到一个名为FooResClass的Java对象中，该对象内部包含一个AData类型的列表：

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class FooResClass extends BaseResModel {
    private List aDataList;

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public class AData { // 注意：此处AData为非静态内部类
        @JsonProperty("number")
        private Long number;
        @JsonProperty("name")
        private String name;
    }
}

直接使用ObjectMapper尝试将上述JSON反序列化为FooResClass实例时，会抛出MismatchedInputException。这是因为：

立即学习“Java免费学习笔记（深入）”；

1. JSON根结构不匹配：提供的JSON是一个数组（[开头），而FooResClass是一个Java对象，Jackson期望JSON的根是一个对象（{开头），并且其中包含一个名为aDataList的字段来映射到FooResClass的aDataList属性。
2. 内部类AData的限制：AData作为FooResClass的非静态内部类，其实例化需要FooResClass的一个实例。Jackson在反序列化时无法独立实例化非静态内部类，这也会导致问题。为了让Jackson能够独立创建AData实例，AData必须声明为static内部类。

解决方案一：直接解析JSON数组到列表

如果JSON字符串本身就是一个列表，我们可以直接将其反序列化为Java的List类型，然后再手动构建FooResClass对象。

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

import java.io.IOException;
import java.util.List;

public class JsonArrayToListExample {

    // 确保AData是静态内部类，以便Jackson可以独立实例化
    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class AData {
        @JsonProperty("number")
        private Long number;
        @JsonProperty("name")
        private String name;
    }

    // 假设FooResClass有一个接收List的构造函数
    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    // 假设BaseResModel存在且FooResClass继承它
    // @EqualsAndHashCode(callSuper = true) // 如果需要
    // @AllArgsConstructor // 如果需要有参构造器
    public static class FooResClass { // FooResClass也应是静态类或顶级类
        private List aDataList;

        public FooResClass(List aDataList) {
            this.aDataList = aDataList;
        }
    }

    public static void main(String[] args) throws IOException {
        String json = "[\n" +
                "    {\n" +
                "        \"name\": \"A\",\n" +
                "        \"number\": 1,\n" +
                "        \"age\": 20\n" +
                "    },\n" +
                "    {\n" +
                "        \"name\": \"B\",\n" +
                "        \"number\": 2,\n" +
                "        \"age\": 30\n" +
                "    },\n" +
                "    {\n" +
                "        \"name\": \"C\",\n" +
                "        \"number\": 3,\n" +
                "        \"age\": 40\n" +
                "    }\n" +
                "]";

        ObjectMapper mapper = new ObjectMapper();

        // 直接将JSON数组解析为List
        List aDataList = mapper.readValue(json, new TypeReference>() {});

        // 使用解析出的列表构建FooResClass实例
        FooResClass fooRes = new FooResClass(aDataList);

        System.out.println("解析成功，FooResClass实例: " + fooRes);
        System.out.println("列表内容: " + fooRes.getADataList());
    }
}

优点：简单直接，适用于JSON结构本身就是目标列表的情况。 缺点：需要手动构建外层对象，如果FooResClass有更多复杂逻辑，这种方式可能不够优雅。

解决方案二：调整JSON结构以匹配POJO

如果我们可以控制JSON的生成方，最直接的解决方案是修改JSON结构，使其与FooResClass的预期完全匹配。这意味着JSON应该是一个对象，其中包含一个名为aDataList的字段，其值是一个数组。

期望的JSON结构应如下所示：

Linfo.ai

Linfo AI 是一款AI驱动的 Chrome 扩展程序，可以将网页文章、行业报告、YouTube 视频和 PDF 文档转换为结构化摘要。

下载

{
   "aDataList":[
      {
         "name":"A",
         "number":1,
         "age":20
      },
      {
         "name":"B",
         "number":2,
         "age":30
      },
      {
         "name":"C",
         "number":3,
         "age":40
      }
   ]
}

在这种情况下，FooResClass的定义保持不变（确保AData是静态内部类），Jackson将能够自动完成反序列化：

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;

import java.io.IOException;
import java.util.List;

public class MatchedJsonStructureExample {

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class AData {
        @JsonProperty("number")
        private Long number;
        @JsonProperty("name")
        private String name;
    }

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class FooResClass {
        @JsonProperty("aDataList") // 确保字段名与JSON中的key匹配
        private List aDataList;
    }

    public static void main(String[] args) throws IOException {
        String json = "{\n" +
                "   \"aDataList\":[\n" +
                "      {\n" +
                "         \"name\":\"A\",\n" +
                "         \"number\":1,\n" +
                "         \"age\":20\n" +
                "      },\n" +
                "      {\n" +
                "         \"name\":\"B\",\n" +
                "         \"number\":2,\n" +
                "         \"age\":30\n" +
                "      },\n" +
                "      {\n" +
                "         \"name\":\"C\",\n" +
                "         \"number\":3,\n" +
                "         \"age\":40\n" +
                "      }\n" +
                "   ]\n" +
                "}";

        ObjectMapper mapper = new ObjectMapper();
        FooResClass fooRes = mapper.readValue(json, FooResClass.class);

        System.out.println("解析成功，FooResClass实例: " + fooRes);
        System.out.println("列表内容: " + fooRes.getADataList());
    }
}

优点：Jackson自动处理，代码简洁，符合POJO设计理念。 缺点：要求修改JSON源，这在许多情况下可能无法实现。

解决方案三：实现自定义反序列化器 (推荐)

当无法修改JSON结构，又希望直接将JSON数组反序列化为包含嵌套列表的FooResClass实例时，自定义反序列化器是最佳选择。通过实现JsonDeserializer或继承StdDeserializer，我们可以完全控制反序列化过程。

首先，确保FooResClass和AData都是静态内部类，并且FooResClass有一个接收List的构造函数（或使用Lombok的@AllArgsConstructor）。

import com.fasterxml.jackson.annotation.JsonCreator; // 用于标记构造函数
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.AllArgsConstructor; // 如果需要有参构造器
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import java.util.List;

// FooResClass 必须是静态的，如果它作为另一个类的内部类存在
// 或者直接作为顶级类
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@AllArgsConstructor // 为FooResClass提供一个接收List的构造函数
@JsonDeserialize(using = FooResClassDeserializer.class) // 指定自定义反序列化器
public static class FooResClass { // 确保是静态内部类或顶级类
    private List aDataList;

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class AData { // 确保是静态内部类
        @JsonProperty("number")
        private Long number;
        @JsonProperty("name")
        private String name;
    }
}

接下来，创建FooResClassDeserializer，它将负责将JSON数组解析为List，然后用这个列表来构造FooResClass实例。

import com.fasterxml.jackson.core.JacksonException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;

import java.io.IOException;
import java.util.List;

public class FooResClassDeserializer extends StdDeserializer {

    public FooResClassDeserializer() {
        this(null);
    }

    public FooResClassDeserializer(Class vc) {
        super(vc);
    }

    @Override
    public FooResClass deserialize(JsonParser p,
                                   DeserializationContext ctxt) throws IOException, JacksonException {
        ObjectMapper mapper = (ObjectMapper) p.getCodec(); // 获取当前的ObjectMapper实例
        // 将整个JSON输入（它是一个数组）解析为List
        List aDataList = mapper.readValue(p, new TypeReference>() {});
        // 使用解析出的列表构建FooResClass实例
        return new FooResClass(aDataList);
    }
}

最后，在使用ObjectMapper进行反序列化时，Jackson会自动查找@JsonDeserialize注解并使用指定的反序列化器。

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

public class CustomDeserializerExample {
    public static void main(String[] args) throws IOException {
        String json = "[\n" +
                "    {\n" +
                "        \"name\": \"A\",\n" +
                "        \"number\": 1,\n" +
                "        \"age\": 20\n" +
                "    },\n" +
                "    {\n" +
                "        \"name\": \"B\",\n" +
                "        \"number\": 2,\n" +
                "        \"age\": 30\n" +
                "    },\n" +
                "    {\n" +
                "        \"name\": \"C\",\n" +
                "        \"number\": 3,\n" +
                "        \"age\": 40\n" +
                "    }\n" +
                "]";

        ObjectMapper mapper = new ObjectMapper();
        // Jackson将使用FooResClass上指定的FooResClassDeserializer
        FooResClass fooRes = mapper.readValue(json, FooResClass.class);

        System.out.println("解析成功，FooResClass实例: " + fooRes);
        System.out.println("列表内容: " + fooRes.getADataList());
    }
}

优点：高度灵活，能够处理各种不匹配的JSON结构，无需修改JSON源。将反序列化逻辑封装起来，提高了代码的可维护性。 缺点：增加了代码量和复杂性，需要编写额外的反序列化器类。

注意事项与总结

1. 静态内部类：无论是哪种解决方案，如果AData是FooResClass的内部类，它都必须声明为static。否则，Jackson无法在没有外部类实例的情况下创建AData的实例。
2. @JsonIgnoreProperties(ignoreUnknown = true)：这个注解非常有用，它告诉Jackson忽略JSON中存在但POJO中没有定义的字段，避免因字段不匹配而抛出异常。
3. Lombok注解：@Data简化了getter/setter、equals、hashCode和toString方法的生成。@AllArgsConstructor可以方便地为所有字段生成构造函数，这在自定义反序列化器中非常有用。
4. TypeReference：在反序列化泛型类型（如List）时，需要使用TypeReference来帮助Jackson获取正确的泛型类型信息。

总而言之，处理JSON数组到包含嵌套列表的Java对象反序列化问题，关键在于理解JSON与POJO之间的结构差异。当JSON结构与POJO预期不符时，我们可以选择直接解析为列表后手动构建，或者在能控制JSON源的情况下调整JSON结构。而当这些方法不可行时，自定义反序列化器提供了一个强大且灵活的解决方案，能够优雅地桥接JSON与POJO之间的差异。选择哪种方法取决于具体的需求、JSON源的可控性以及对代码复杂度的接受程度。