本文旨在解决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<AData> 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<AData>。
- 通过构造函数或其他方法将 List<AData> 赋值给 FooResClass 的 aDataList 字段。
示例代码：
首先，修改 AData 类使其成为静态内部类，并为 FooResClass 添加一个接收 List<AData> 的构造函数（或使用 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<AData> aDataList;
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class AData { // 必须是 static
@JsonProperty("number")
private Long number;
@JsonProperty("name")
private String name;
}
}然后，进行反序列化：
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<AData>
List<FooResClass.AData> aDataList = mapper.readValue(json, new TypeReference<List<FooResClass.AData>>(){});
// 使用获取到的列表构建 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<FooResClass> 的自定义反序列化器类，例如 FooResClassDeserializer。
- 在 deserialize 方法中，使用 ObjectMapper 将传入的 JsonParser 读取为 List<AData>。
- 使用该列表构建并返回 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<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 注解，并确保 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<AData> 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字段名不一致时进行映射。
通过本文提供的三种解决方案，开发者可以有效地处理Jackson在JSON反序列化过程中遇到的结构不匹配问题，从而提高数据处理的健壮性和灵活性。在实际开发中，根据具体场景和对JSON结构的控制能力，选择最合适的方案至关重要。
