当JSON数据中存在一个字段，其值本身是一个需要进一步解析的JSON字符串时，Jackson的默认反序列化机制无法直接处理。本文将详细介绍如何通过实现`JsonDeserializer`和`ContextualDeserializer`接口，创建一个通用的自定义反序列化器，以动态识别目标类型并正确解析这些嵌套的JSON字符串，从而将复杂的JSON结构映射到Java对象，并提供完整的代码示例和使用指南。
1. 问题背景与默认Jackson行为
在处理JSON数据时，我们有时会遇到这样的场景：一个JSON字段的值不是一个标准的JSON对象或数组，而是一个被引号包裹的JSON字符串。例如：
{
"name": "g1",
"users": "[{\"name\":\"u1\",\"id\":1},{\"name\":\"u2\",\"id\":2}]"
}这里，users字段的值是一个字符串，但其内容实际上是一个JSON数组的字符串表示。如果我们尝试将其反序列化到如下Java对象结构：
import java.util.List;
class User {
private String name;
private Long id;
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
@Override
public String toString() {
return "User{" + "name='" + name + '\'' + ", id=" + id + '}';
}
}
class Group {
private String name;
private List users;
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public List getUsers() { return users; }
public void setUsers(List users) { this.users = users; }
@Override
public String toString() {
return "Group{" + "name='" + name + '\'' + ", users=" + users + '}';
}
} 直接使用Jackson的ObjectMapper进行反序列化：
ObjectMapper objectMapper = new ObjectMapper();
String jsonText = "{\"name\":\"g1\",\"users\":\"[{\\\"name\\\":\\\"u1\\\",\\\"id\\\":1},{\\\"name\\\":\\\"u2\\\",\\\"id\\\":2}]\"}";
Group group = objectMapper.readValue(jsonText, Group.class);此时，Jackson会将users字段的值作为一个普通的字符串赋给List
2. 解决方案：自定义JsonDeserializer与ContextualDeserializer
为了解决这个问题，我们需要实现一个自定义的Jackson反序列化器。这个反序列化器需要完成两个主要任务：
- 识别出字段的值是一个需要二次解析的JSON字符串。
- 获取到该字段的实际目标类型（例如List
），并使用ObjectMapper对该字符串进行二次反序列化。
由于目标类型（List
2.1 实现RawJsonDeserializer
我们创建一个名为RawJsonDeserializer的通用反序列化器。
import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.BeanProperty; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JsonDeserializer; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.deser.ContextualDeserializer; import com.fasterxml.jackson.databind.type.SimpleType; import java.io.IOException; public class RawJsonDeserializerextends JsonDeserializer implements ContextualDeserializer { private final JavaType type; // 用于存储目标类型 // 默认构造函数，通常在没有上下文时使用，或作为ContextualDeserializer的起点 public RawJsonDeserializer() { // 初始时设置为Object.class，等待ContextualDeserializer提供具体类型 this.type = SimpleType.constructUnsafe(Object.class); } // 带JavaType参数的构造函数，由createContextual方法调用，传入具体的泛型类型 public RawJsonDeserializer(JavaType type) { this.type = type; } /** * createContextual 方法是ContextualDeserializer接口的核心。 * 它允许我们在反序列化器被应用到特定属性时，获取该属性的类型信息。 * * @param ctxt 反序列化上下文 * @param property 当前正在反序列化的属性（字段） * @return 一个新的JsonDeserializer实例，该实例已根据属性的实际类型进行配置 * @throws JsonMappingException 如果在创建过程中发生映射错误 */ @Override public JsonDeserializer createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { // 如果property不为空，说明我们正在处理一个具体的字段 if (property != null) { // 获取该字段的完整JavaType，包括泛型信息 (e.g., List ) JavaType actualType = property.getType(); // 返回一个新的RawJsonDeserializer实例，传入获取到的实际类型 return new RawJsonDeserializer<>(actualType); } // 如果property为空（例如，直接反序列化一个根对象），则返回当前实例 return this; } /** * deserialize 方法执行实际的反序列化逻辑。 * * @param p JSON解析器，用于读取JSON流 * @param ctxt 反序列化上下文 * @return 反序列化后的Java对象 * @throws IOException 如果在读取或解析过程中发生I/O错误 */ @Override public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { // 获取当前JSON令牌的文本值，即被引号包裹的JSON字符串 String rawJsonString = p.getText(); // 获取当前使用的ObjectMapper实例，用于对嵌套的JSON字符串进行二次反序列化 ObjectMapper objectMapper = (ObjectMapper) p.getCodec(); // 使用ObjectMapper将原始JSON字符串反序列化为我们在createContextual中确定的目标类型 // 如果type是List ，它将正确地解析为List return objectMapper.readValue(rawJsonString, type); } }
2.2 RawJsonDeserializer工作原理详解
-
ContextualDeserializer: 这个接口是关键。当Jackson遇到一个需要自定义反序列化的字段时，如果其JsonDeserializer实现了ContextualDeserializer，Jackson会调用createContextual方法。在这个方法中，我们可以通过property.getType()获取到当前字段的完整JavaType（例如List
），然后创建一个新的RawJsonDeserializer实例，并将这个具体的JavaType传递给它。这样，我们的反序列化器就“知道”它需要将字符串解析成什么类型了。 - deserialize: 在这个方法中，我们首先通过p.getText()获取到原始的JSON字符串（即"[{\\"name\\":\\"u1\\",\\"id\\":1},{\\"name\\":\\"u2\\",\\"id\\":2}]"）。然后，我们通过p.getCodec()获取到当前正在使用的ObjectMapper实例，并利用它将这个原始字符串再次反序列化为在createContextual中确定的目标类型type。
3. 应用自定义反序列化器
现在，我们需要告诉Jackson在反序列化Group类中的users字段时使用我们自定义的RawJsonDeserializer。这通过在字段上添加@JsonDeserialize注解实现。
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import java.util.List;
class User {
private String name;
private Long id;
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
@Override
public String toString() {
return "User{" + "name='" + name + '\'' + ", id=" + id + '}';
}
}
class Group {
private String name;
// 使用@JsonDeserialize注解指定自定义反序列化器
@JsonDeserialize(using = RawJsonDeserializer.class)
private List users;
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public List getUsers() { return users; }
public void setUsers(List users) { this.users = users; }
@Override
public String toString() {
return "Group{" + "name='" + name + '\'' + ", users=" + users + '}';
}
} 4. 完整示例代码
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.type.SimpleType;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import java.io.IOException;
import java.util.List;
// User类定义
class User {
private String name;
private Long id;
public User() {} // Jackson需要无参构造函数
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
@Override
public String toString() {
return "User{" + "name='" + name + '\'' + ", id=" + id + '}';
}
}
// Group类定义，应用自定义反序列化器
class Group {
private String name;
@JsonDeserialize(using = RawJsonDeserializer.class)
private List users;
public Group() {} // Jackson需要无参构造函数
// Getters and Setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public List getUsers() { return users; }
public void setUsers(List users) { this.users = users; }
@Override
public String toString() {
return "Group{" + "name='" + name + '\'' + ", users=" + users + '}';
}
}
// RawJsonDeserializer定义 (同上)
public class RawJsonDeserializer extends JsonDeserializer implements ContextualDeserializer {
private final JavaType type;
public RawJsonDeserializer() {
this.type = SimpleType.constructUnsafe(Object.class);
}
public RawJsonDeserializer(JavaType type) {
this.type = type;
}
@Override
public JsonDeserializer createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
if (property != null) {
JavaType actualType = property.getType();
return new RawJsonDeserializer<>(actualType);
}
return this;
}
@Override
public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
String rawJsonString = p.getText();
ObjectMapper objectMapper = (ObjectMapper) p.getCodec();
return objectMapper.readValue(rawJsonString, type);
}
}
// 主类用于测试
public class JacksonNestedJsonDeserialization {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
// 注意：这里的jsonText中的内部JSON字符串需要进行转义，以符合Java字符串字面量规则
String jsonText = "{\"name\":\"g1\",\"users\":\"[{\\\"name\\\":\\\"u1\\\",\\\"id\\\":1},{\\\"name\\\":\\\"u2\\\",\\\"id\\\":2}]\"}";
System.out.println("原始JSON字符串:\n" + jsonText);
Group group = objectMapper.readValue(jsonText, Group.class);
System.out.println("\n反序列化后的Group对象:\n" + group);
System.out.println("Group Name: " + group.getName());
System.out.println("Users List: " + group.getUsers());
if (group.getUsers() != null) {
for (User user : group.getUsers()) {
System.out.println(" User: " + user.getName() + ", ID: " + user.getId());
}
}
}
} 运行上述main方法，将得到如下输出：
原始JSON字符串:
{"name":"g1","users":"[{\"name\":\"u1\",\"id\":1},{\"name\":\"u2\",\"id\":2}]"}
反序列化后的Group对象:
Group{name='g1', users=[User{name='u1', id=1}, User{name='u2', id=2}]}
Group Name: g1
Users List: [User{name='u1', id=1}, User{name='u2', id=2}]
User: u1, ID: 1
User: u2, ID: 2这表明嵌套的JSON字符串已成功反序列化为List
5. 注意事项与总结
- 性能考量: 这种方法本质上是对一个JSON字符串进行了两次解析（一次是外层JSON，一次是内层JSON字符串）。如果这种结构大量存在，可能会对性能产生一定影响。在可能的情况下，优化JSON的生成方式，避免使用嵌套的JSON字符串是更优的选择。
- 通用性: RawJsonDeserializer是一个非常通用的解决方案，可以用于任何字段，只要其值是需要二次解析的JSON字符串，并且我们希望将其反序列化为该字段声明的Java类型。
- 错误处理: 在实际应用中，你可能需要为deserialize方法添加更健壮的错误处理逻辑，例如当p.getText()返回的字符串不是有效的JSON时，或者目标类型无法匹配时。
-
contentAs: 原始问题答案中提到了contentAs，它通常用于处理泛型集合或映射中的元素类型。在我们的RawJsonDeserializer中，createContextual已经动态获取了List
的完整JavaType，所以contentAs在此场景下并非必需，Jackson会正确处理List 。 -
Maven依赖: 确保项目中包含了Jackson的核心依赖：
com.fasterxml.jackson.core jackson-databind 2.13.0
通过上述方法，我们可以优雅地解决Jackson在反序列化嵌套JSON字符串时的挑战，使得复杂且非标准格式的JSON数据也能被有效地映射到Java对象模型中。
