深入理解Jackson JSON反序列化中的结构不匹配问题

DDD

发布时间：2025-11-27 17:12:28

450人浏览过

来源于php中文网

原创

深入理解Jackson JSON反序列化中的结构不匹配问题

本文旨在解决jackson在处理json字符串到java对象转换时常见的`mismatchedinputexception`。当json结构与目标pojo定义不符时，jackson无法正确映射数据。文章将详细阐述导致此类错误的原因，并提供三种有效的解决方案：直接将json数组反序列化为列表、调整json结构以匹配pojo，以及通过自定义反序列化器灵活处理不匹配的json结构，帮助开发者高效、准确地进行json数据转换。

在Java开发中，使用Jackson库进行JSON与Java对象（POJO）之间的序列化和反序列化是常见操作。然而，当JSON的结构与目标POJO的定义不完全匹配时，Jackson可能会抛出MismatchedInputException异常。本教程将深入分析这种异常产生的原因，并提供多种实用的解决方案，确保JSON数据能够顺利地转换为所需的Java对象。

1. 问题根源分析：JSON与POJO结构不匹配

原始问题中，JSON字符串是一个对象数组：

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

而目标POJO FooResClass 期望的结构是包含一个 aDataList 字段的根对象：

public class FooResClass extends BaseResModel {
    private List aDataList;
    // ... AData nested class
}

这种结构上的差异是导致MismatchedInputException的直接原因。Jackson尝试将一个JSON数组反序列化为 FooResClass 的实例时，发现根级别不是一个JSON对象，而是数组，因此无法完成映射。

此外，值得注意的是，如果 AData 是 FooResClass 的一个嵌套类，它必须被声明为 static。非静态内部类需要其外部类的实例才能被实例化，而Jackson在反序列化时通常无法提供这种外部实例，从而导致实例化失败。

2. 解决方案

针对上述问题，我们有以下几种策略来解决。

2.1 方案一：直接反序列化为列表并构建目标对象

如果JSON的根元素是一个数组，并且该数组中的每个元素都直接对应于POJO中的某个子类型（如本例中的 AData），那么最直接的方法是先将JSON数组反序列化为该子类型的列表，然后再手动将此列表封装到最终的目标POJO中。

实现步骤：

确保嵌套类 AData 声明为 static。
使用 ObjectMapper 将JSON直接反序列化为 List。
通过构造函数或其他方法将 List 赋值给 FooResClass 的 aDataList 字段。

示例代码：

首先，修改 AData 类使其成为静态内部类，并为 FooResClass 添加一个接收 List 的构造函数（或使用 Lombok 的 @AllArgsConstructor）：

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

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

// 假设 BaseResModel 是一个基础模型类
class BaseResModel implements Serializable {
    private static final long serialVersionUID = 1L;
}

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode(callSuper = true)
@AllArgsConstructor // 添加全参构造函数以便于构建
public class FooResClass extends BaseResModel {

    private static final long serialVersionUID = -6398045272254450504L;

    private List aDataList;

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

然后，进行反序列化：

Batch GPT

使用AI批量处理数据、自动执行任务

下载

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.List;

public class JsonDeserializationExample {
    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("Deserialization successful!");
        fooRes.getADataList().forEach(data ->
            System.out.println("Name: " + data.getName() + ", Number: " + data.getNumber())
        );
    }
}

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

如果可以修改JSON的结构，那么最简单且最符合Jackson常规用法的方法是使JSON的结构与 FooResClass 的定义完全匹配。这意味着JSON应该是一个包含 aDataList 字段的根对象。

期望的JSON结构：

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

通过这种方式，Jackson可以直接将整个JSON字符串反序列化为 FooResClass 的实例，无需额外的处理。

// 假设 JSON 结构已修改为上述形式
String jsonWithWrapper = "{\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(jsonWithWrapper, FooResClass.class);
// ... 后续操作

2.3 方案三：自定义反序列化器（推荐处理不可变JSON）

当无法改变JSON结构，且需要直接将JSON数组反序列化为 FooResClass 的实例时，自定义反序列化器是最佳选择。它允许我们精确控制反序列化过程，将原始JSON数组转换为 FooResClass 对象。

实现步骤：

创建一个继承自 StdDeserializer 的自定义反序列化器类，例如 FooResClassDeserializer。
在 deserialize 方法中，使用 ObjectMapper 将传入的 JsonParser 读取为 List。
使用该列表构建并返回 FooResClass 实例。
在 FooResClass 上使用 @JsonDeserialize(using = FooResClassDeserializer.class) 注解来指定使用此自定义反序列化器。

示例代码：

首先，定义自定义反序列化器：

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);
    }
}

然后，在 FooResClass 上应用 @JsonDeserialize 注解，并确保 AData 是 static 内部类：

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.EqualsAndHashCode;

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

// 假设 BaseResModel 是一个基础模型类
// class BaseResModel implements Serializable { /* ... */ } // 已在上方定义

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode(callSuper = true)
@AllArgsConstructor
@JsonDeserialize(using = FooResClassDeserializer.class) // 指定使用自定义反序列化器
public class FooResClass extends BaseResModel {

    private static final long serialVersionUID = -6398045272254450504L;

    // @JsonProperty("aDataList") // 此处不再需要，因为自定义反序列器直接处理整个JSON数组
    private List aDataList;

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

现在，可以直接将原始JSON数组反序列化为 FooResClass 实例：

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

public class CustomDeserializationExample {
    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();
        FooResClass fooRes = mapper.readValue(json, FooResClass.class);

        System.out.println("Deserialization with custom deserializer successful!");
        fooRes.getADataList().forEach(data ->
            System.out.println("Name: " + data.getName() + ", Number: " + data.getNumber())
        );
    }
}

3. 注意事项与总结

静态内部类： 嵌套在其他类中的POJO如果需要被Jackson独立实例化，必须声明为 static。
JSON与POJO结构匹配： Jackson默认的反序列化机制高度依赖于JSON结构与POJO字段的直接映射。理解这一点是解决大部分 MismatchedInputException 的关键。
选择合适的方案：
- 如果JSON结构可以修改，优先调整JSON以匹配POJO，这是最简洁的方式。
- 如果JSON是数组，且数组元素直接对应子POJO，可以先反序列化为列表，再手动组装。
- 如果JSON结构不可变，且需要将非标准结构的JSON映射到特定POJO，自定义反序列化器提供了最大的灵活性和控制力。
@JsonIgnoreProperties(ignoreUnknown = true)： 这个注解非常有用，它告诉Jackson忽略JSON中存在但POJO中没有定义的字段，避免因多余字段导致的错误。
@JsonProperty： 用于指定JSON字段名与Java字段名不一致时进行映射。