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免费学习笔记（深入）”；

JSON根结构不匹配：提供的JSON是一个数组（[开头），而FooResClass是一个Java对象，Jackson期望JSON的根是一个对象（{开头），并且其中包含一个名为aDataList的字段来映射到FooResClass的aDataList属性。内部类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": 20n" +                "    },n" +                "    {n" +                "        "name": "B",n" +                "        "number": 2,n" +                "        "age": 30n" +                "    },n" +                "    {n" +                "        "name": "C",n" +                "        "number": 3,n" +                "        "age": 40n" +                "    }n" +                "]";        ObjectMapper mapper = new ObjectMapper();        // 直接将JSON数组解析为List        List aDataList = mapper.readValue(json, new TypeReference<List>() {});        // 使用解析出的列表构建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结构应如下所示：

九歌

九歌–人工智能诗歌写作系统

322 查看详情

{   "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":20n" +                "      },n" +                "      {n" +                "         "name":"B",n" +                "         "number":2,n" +                "         "age":30n" +                "      },n" +                "      {n" +                "         "name":"C",n" +                "         "number":3,n" +                "         "age":40n" +                "      }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<List>() {});        // 使用解析出的列表构建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": 20n" +                "    },n" +                "    {n" +                "        "name": "B",n" +                "        "number": 2,n" +                "        "age": 30n" +                "    },n" +                "    {n" +                "        "name": "C",n" +                "        "number": 3,n" +                "        "age": 40n" +                "    }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源。将反序列化逻辑封装起来，提高了代码的可维护性。缺点：增加了代码量和复杂性，需要编写额外的反序列化器类。

注意事项与总结

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

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

以上就是Jackson反序列化：处理JSON数组到嵌套List的Java对象映射的详细内容，更多请关注创想鸟其它相关文章！