使用Jackson处理JSON数组根的POJO映射与自定义反序列化-java教程-PHP中文网

使用jackson处理json数组根的pojo映射与自定义反序列化

本文探讨了在使用Jackson库将JSON字符串反序列化为Java对象时常见的`MismatchedInputException`，特别是当JSON根是一个数组而非对象时。文章详细分析了JSON结构与POJO定义不匹配的原因，并提供了三种解决方案：直接将JSON数组反序列化为列表、调整JSON结构以匹配POJO，以及通过自定义反序列化器实现灵活映射。

理解Jackson反序列化中的MismatchedInputException

在使用Jackson库将JSON字符串转换为Java对象（POJO）时，如果JSON的结构与目标POJO的定义不匹配，常常会遇到com.fasterxml.jackson.databind.exc.MismatchedInputException异常。这种异常通常表明Jackson无法将输入的JSON类型（例如，JSON数组）映射到预期的Java类型（例如，包含列表字段的Java对象）。

问题场景示例：

假设我们有一个JSON字符串，其根是一个对象数组：

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

登录后复制

我们希望将其反序列化到一个包含AData列表的FooResClass对象中，其中AData只关注name和number字段。POJO定义如下：

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode(callSuper = true)
public class FooResClass extends BaseResModel {
    private static final long serialVersionUID = -6398045272254450504L;
    private List<AData> aDataList;

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

登录后复制

直接尝试将上述JSON字符串反序列化为FooResClass.class会导致MismatchedInputException。

异常原因分析：

JSON根类型不匹配： 提供的JSON字符串是一个JSON数组（[...]），而FooResClass是一个Java对象，它期望一个JSON对象（{...}）作为根，其中包含一个名为aDataList的字段。Jackson尝试将一个JSON数组直接映射到一个Java对象时，会因为类型不兼容而失败。
嵌套类定义： 如果AData是一个嵌套在FooResClass内部的非静态类，Jackson在尝试实例化AData时会失败，因为它需要一个外部FooResClass的实例才能创建内部类的实例。为了让Jackson能够独立地实例化内部类，AData必须被声明为static。

解决方案

针对上述问题，有几种不同的处理策略，选择哪种取决于您是否能修改JSON结构以及对代码灵活性的要求。

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

如果JSON的根始终是一个数组，并且您希望将其内容映射到某个POJO的列表字段中，最直接的方法是先将JSON数组反序列化为对应的List<AData>，然后再手动构建FooResClass实例。

代码示例：

首先，确保内部类AData是static的，并且FooResClass有一个合适的构造函数来接收AData列表。

ima.copilot

腾讯大混元模型推出的智能工作台产品，提供知识库管理、AI问答、智能写作等功能

317

查看详情

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

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

// 假设BaseResModel是一个基础模型类，这里简化为接口或空类
interface BaseResModel extends Serializable {}

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode(callSuper = true)
@AllArgsConstructor // 添加全参数构造函数
public class FooResClass extends BaseResModel {
    private static final long serialVersionUID = -6398045272254450504L;
    private List<AData> aDataList;

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

public class JsonDeserializationExample {
    public static void main(String[] args) throws IOException {
        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. 直接将JSON数组反序列化为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结构固定为数组且不需要额外封装的情况。

方案二：调整JSON结构以匹配POJO（如果可行）

如果可以修改JSON的生产者，最理想的解决方案是调整JSON结构，使其直接匹配FooResClass的定义。这意味着JSON的根应该是一个对象，其中包含一个名为aDataList的字段，其值是一个数组。

期望的JSON结构：

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

登录后复制

如果JSON结构变为这样，那么您就可以直接使用mapper.readValue(jsonString, FooResClass.class)进行反序列化，Jackson会自动将aDataList字段映射到FooResClass中的List<AData>。

方案三：自定义反序列化器（当JSON结构不可更改时）

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

步骤：

创建自定义反序列化器： 继承com.fasterxml.jackson.databind.deser.std.StdDeserializer并实现deserialize方法。
注册反序列化器： 使用@JsonDeserialize注解将自定义反序列化器绑定到目标POJO。

自定义反序列化器示例：

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实例，用于解析当前JSON流
        // 注意：这里需要确保JsonParser p 能够被 ObjectMapper.readValue() 正确处理
        // 如果JsonParser已经指向了数组的开始，可以直接读取
        ObjectMapper mapper = (ObjectMapper) p.getCodec(); // 获取当前上下文的ObjectMapper
        List<FooResClass.AData> aDataList = mapper.readValue(p, new TypeReference<List<FooResClass.AData>>() {});
        return new FooResClass(aDataList);
    }
}

登录后复制

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

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

// 假设BaseResModel是一个基础模型类，这里简化为接口或空类
interface BaseResModel extends Serializable {}

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode(callSuper = true)
@AllArgsConstructor // 添加全参数构造函数
@JsonDeserialize(using = FooResClassDeserializer.class) // 注册自定义反序列化器
public static class FooResClass extends BaseResModel { // 确保是静态类，如果FooResClass本身是内部类
    private static final long serialVersionUID = -6398045272254450504L;

    @JsonProperty("aDataList") // 即使JSON中没有此字段，在POJO中定义它有助于清晰性
    private List<AData> aDataList;

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

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

        ObjectMapper mapper = new ObjectMapper();

        // 现在可以直接将JSON数组反序列化为FooResClass实例
        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的映射逻辑更符合业务需求，这种方法提供了最大的灵活性和可维护性。

总结与注意事项

静态内部类： 当一个POJO类（如AData）作为另一个POJO类（如FooResClass）的成员类型时，如果它是嵌套定义的，请务必将其声明为static。否则，Jackson在反序列化时将无法独立实例化它，导致失败。
JSON与POJO结构匹配： Jackson反序列化的核心原则是JSON结构与POJO结构的高度匹配。当遇到MismatchedInputException时，首先应检查JSON的根类型（对象{}或数组[]）是否与您尝试反序列化的Java类型（对象或列表）一致。
TypeReference的重要性： 在反序列化泛型类型（如List<AData>）时，TypeReference是必不可少的，它帮助Jackson在运行时获取完整的泛型类型信息。
选择合适的方案：
- 如果JSON是数组且您只关心数组内容，方案一（直接反序列化为列表）最简单。
- 如果可以控制JSON源，方案二（修改JSON结构）是最佳实践，它使POJO映射最直观。
- 如果JSON结构不可更改且需要将数组封装到特定POJO中，方案三（自定义反序列化器）提供了最强大的控制力。