当使用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。原因在于：
- JSON根元素类型不匹配： 提供的JSON是一个数组，而FooResClass是一个JSON对象（它本身不是数组）。Jackson期望将JSON数组映射到List类型或数组类型，而不是一个包含List字段的普通对象。
- 内部类限制： 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.AData>，再用这个列表去构造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<FooResClass>的类，并重写其deserialize方法。在这个方法中，我们将执行将JSON数组解析为List<AData>，然后用这个列表来构建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对象模型中。
