登录
首页 >  文章 >  java教程

Jackson反序列化JSON数组到嵌套对象方法

时间：2025-12-23 13:36:51 441浏览 收藏

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Jackson反序列化JSON数组到嵌套POJO方法》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

Jackson反序列化JSON数组到嵌套POJO的策略与实践

当使用Jackson库将JSON字符串反序列化为Java对象时，常见的挑战是JSON结构与目标POJO类定义不匹配，尤其是在JSON根元素为数组而POJO期望一个包含列表的复杂对象时。本文将深入探讨导致`MismatchedInputException`的原因，并提供三种有效的解决方案：直接反序列化为列表、调整JSON结构（如果可行），以及通过自定义反序列化器实现灵活映射，旨在帮助开发者更准确、高效地处理此类场景。

理解Jackson反序列化错误：MismatchedInputException

在Java开发中，Jackson是一个广泛使用的JSON处理库。当尝试将一个JSON字符串反序列化为Java对象时，如果JSON的结构与目标Java对象（POJO）的结构不匹配，Jackson会抛出MismatchedInputException。

以以下JSON为例：

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

这是一个JSON数组，其每个元素都是一个包含name、number和age字段的对象。

假设我们有一个POJO类FooResClass，它包含一个AData对象的列表：

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class FooResClass {
    private List<AData> aDataList;

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

当我们尝试直接将上述JSON数组反序列化为FooResClass的实例时，就会遇到MismatchedInputException。原因在于：

  1. JSON根元素类型不匹配： 提供的JSON是一个数组，而FooResClass是一个JSON对象（它本身不是数组）。Jackson期望将JSON数组映射到List类型或数组类型，而不是一个包含List字段的普通对象。
  2. 内部类限制： AData作为非静态内部类，其实例化需要外部类FooResClass的实例。Jackson在反序列化时无法独立实例化非静态内部类，除非有特殊配置。因此，AData应该被定义为static内部类。

解决方案

针对上述问题，有几种不同的策略可以解决，选择哪种取决于JSON结构的可变性以及代码的灵活性需求。

1. 直接反序列化为列表，然后构建外部对象

如果JSON的根元素确实是一个数组，并且您只想提取数组中的数据，最直接的方法是将其反序列化为Java的List类型。

修改AData类： 首先，确保AData是一个static内部类，这样Jackson才能独立地实例化它。同时，为了演示完整性，我们为FooResClass添加一个构造函数以便于列表传入。

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.List;

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@NoArgsConstructor // 添加无参构造函数
@AllArgsConstructor // 添加全参构造函数
public class FooResClass implements Serializable { // 假设BaseResModel实现了Serializable
    private static final long serialVersionUID = -6398045272254450504L;

    @JsonProperty("aDataList") // 即使JSON中没有这个键，为了保持POJO结构，可以保留
    private List<AData> aDataList;

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

反序列化代码： 然后，我们可以将JSON直接反序列化为List，再用这个列表去构造FooResClass的实例。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

public class JsonDeserializationExample {

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

        ObjectMapper mapper = new ObjectMapper();

        // 1. 直接反序列化为 List<AData>
        List<FooResClass.AData> aDataList = mapper.readValue(jsonString, new TypeReference<List<FooResClass.AData>>() {});

        // 2. 使用反序列化得到的列表构造 FooResClass 实例
        FooResClass fooRes = new FooResClass(aDataList);

        System.out.println("反序列化成功！");
        fooRes.getADataList().forEach(data ->
            System.out.println("Name: " + data.getName() + ", Number: " + data.getNumber())
        );
    }
}

这种方法简单直接，适用于JSON根元素就是所需数据列表的情况。

2. 修改JSON结构以匹配POJO（如果可行）

如果JSON结构可以被修改，那么最符合FooResClass定义的JSON结构应该是这样的：

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

在这种情况下，JSON的根元素是一个对象，其中包含一个名为aDataList的字段，其值是实际的数据数组。这样，Jackson就可以直接将整个JSON字符串反序列化为FooResClass的实例。

// ... FooResClass 和 AData 定义不变 ...

public class JsonDeserializationExample {

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

        ObjectMapper mapper = new ObjectMapper();

        // 直接反序列化为 FooResClass
        FooResClass fooRes = mapper.readValue(modifiedJsonString, FooResClass.class);

        System.out.println("修改JSON结构后反序列化成功！");
        fooRes.getADataList().forEach(data ->
            System.out.println("Name: " + data.getName() + ", Number: " + data.getNumber())
        );
    }
}

这种方法最为优雅，因为它完美地匹配了POJO的设计意图。然而，在许多实际场景中，我们可能无法控制JSON的生成方。

3. 使用自定义反序列化器

当无法修改JSON结构，但又希望直接将原始JSON数组反序列化为FooResClass的实例时，自定义反序列化器是最佳选择。它允许我们完全控制反序列化的过程。

创建自定义反序列化器： 我们需要创建一个继承自StdDeserializer的类，并重写其deserialize方法。在这个方法中，我们将执行将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<FooResClass> {

    public FooResClassDeserializer() {
        this(null);
    }

    public FooResClassDeserializer(Class<FooResClass> vc) {
        super(vc);
    }

    @Override
    public FooResClass deserialize(JsonParser p,
                                   DeserializationContext ctxt) throws IOException, JacksonException {

        ObjectMapper mapper = (ObjectMapper) p.getCodec(); // 获取当前的ObjectMapper实例
        // 将JSON数组反序列化为 List<AData>
        List<FooResClass.AData> aDataList = mapper.readValue(p, new TypeReference<List<FooResClass.AData>>() {});
        // 使用列表构造 FooResClass 实例
        return new FooResClass(aDataList);
    }
}

注册自定义反序列化器： 通过在FooResClass上使用@JsonDeserialize注解，并指定using属性为自定义反序列化器类，来告诉Jackson在处理FooResClass时使用我们的自定义逻辑。

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.List;

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@NoArgsConstructor
@AllArgsConstructor
@JsonDeserialize(using = FooResClassDeserializer.class) // 注册自定义反序列化器
public class FooResClass implements Serializable {
    private static final long serialVersionUID = -6398045272254450504L;

    @JsonProperty("aDataList")
    private List<AData> aDataList;

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

反序列化代码： 现在，即使使用原始的JSON数组字符串，也可以直接反序列化为FooResClass的实例。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonDeserializationExample {

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

        ObjectMapper mapper = new ObjectMapper();

        // 直接反序列化为 FooResClass，Jackson会自动调用 FooResClassDeserializer
        FooResClass fooRes = mapper.readValue(jsonString, FooResClass.class);

        System.out.println("使用自定义反序列化器反序列化成功！");
        fooRes.getADataList().forEach(data ->
            System.out.println("Name: " + data.getName() + ", Number: " + data.getNumber())
        );
    }
}

这种方法提供了最大的灵活性和控制力，是处理复杂或不规则JSON结构的推荐方式。

总结与注意事项

  • 内部类必须是静态的： 当在外部类中定义嵌套的POJO类用于Jackson反序列化时，务必将其声明为static，否则Jackson无法独立实例化。
  • JSON结构与POJO匹配： 这是Jackson反序列化的核心原则。如果JSON是数组，应尝试反序列化为List或数组类型；如果JSON是对象，应反序列化为对应的POJO。
  • @JsonIgnoreProperties(ignoreUnknown = true)： 这个注解非常有用，它允许POJO忽略JSON中存在但POJO中没有定义的字段，从而避免不必要的错误。
  • @JsonProperty： 用于指定JSON字段名与POJO属性名不一致时的映射关系。
  • 选择合适的解决方案：
    • 如果JSON结构简单且可以直接映射到List，方案1（直接反序列化为列表）最简单。
    • 如果能控制JSON的生成，方案2（修改JSON结构）是最理想的。
    • 如果JSON结构复杂或无法修改，且需要将数组映射到包含列表的复杂对象，方案3（自定义反序列化器）提供了最强大的灵活性和控制力。

通过理解这些原理和掌握上述解决方案，开发者可以更有效地处理Jackson反序列化中遇到的MismatchedInputException，确保JSON数据能够准确无误地映射到Java对象模型中。

本篇关于《Jackson反序列化JSON数组到嵌套对象方法》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！

相关阅读
更多>
最新阅读
更多>
课程推荐
更多>