本文探讨了在使用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是static的，并且FooResClass有一个合适的构造函数来接收AData列表。
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
方案三：自定义反序列化器（当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
）时，TypeReference是必不可少的，它帮助Jackson在运行时获取完整的泛型类型信息。 -
选择合适的方案：
- 如果JSON是数组且您只关心数组内容，方案一（直接反序列化为列表）最简单。
- 如果可以控制JSON源，方案二（修改JSON结构）是最佳实践，它使POJO映射最直观。
- 如果JSON结构不可更改且需要将数组封装到特定POJO中，方案三（自定义反序列化器）提供了最强大的控制力。
理解这些原则和解决方案，将有助于您更高效地使用Jackson处理各种复杂的JSON反序列化场景。
