使用Jackson自定义反序列化器处理嵌套JSON字符串-java教程-PHP中文网

使用jackson自定义反序列化器处理嵌套json字符串

当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<User> users;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<User> getUsers() { return users; }
    public void setUsers(List<User> 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<User>字段，导致类型转换失败或得到一个包含单个字符串元素的列表，而非预期的List<User>对象。这是因为Jackson默认情况下不会对字符串类型的值进行二次JSON解析。

2. 解决方案：自定义JsonDeserializer与ContextualDeserializer

为了解决这个问题，我们需要实现一个自定义的Jackson反序列化器。这个反序列化器需要完成两个主要任务：

识别出字段的值是一个需要二次解析的JSON字符串。
获取到该字段的实际目标类型（例如List<User>），并使用ObjectMapper对该字符串进行二次反序列化。

由于目标类型（List<User>）是泛型且在运行时才能确定，我们需要结合ContextualDeserializer接口来动态获取类型信息。

Vheer

AI图像处理平台

125

查看详情

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 RawJsonDeserializer<T> extends JsonDeserializer<T> 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<User>)
            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<User>，它将正确地解析为List<User>
        return objectMapper.readValue(rawJsonString, type);
    }
}

登录后复制

2.2 RawJsonDeserializer工作原理详解

ContextualDeserializer: 这个接口是关键。当Jackson遇到一个需要自定义反序列化的字段时，如果其JsonDeserializer实现了ContextualDeserializer，Jackson会调用createContextual方法。在这个方法中，我们可以通过property.getType()获取到当前字段的完整JavaType（例如List<User>），然后创建一个新的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<User> users;

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<User> getUsers() { return users; }
    public void setUsers(List<User> 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<User> users;

    public Group() {} // Jackson需要无参构造函数

    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<User> getUsers() { return users; }
    public void setUsers(List<User> users) { this.users = users; }

    @Override
    public String toString() {
        return "Group{" + "name='" + name + ''' + ", users=" + users + '}';
    }
}

// RawJsonDeserializer定义 (同上)
public class RawJsonDeserializer<T> extends JsonDeserializer<T> 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字符串:
" + jsonText);

        Group group = objectMapper.readValue(jsonText, Group.class);

        System.out.println("
反序列化后的Group对象:
" + 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<User>对象。

5. 注意事项与总结

性能考量: 这种方法本质上是对一个JSON字符串进行了两次解析（一次是外层JSON，一次是内层JSON字符串）。如果这种结构大量存在，可能会对性能产生一定影响。在可能的情况下，优化JSON的生成方式，避免使用嵌套的JSON字符串是更优的选择。
通用性: RawJsonDeserializer是一个非常通用的解决方案，可以用于任何字段，只要其值是需要二次解析的JSON字符串，并且我们希望将其反序列化为该字段声明的Java类型。
错误处理: 在实际应用中，你可能需要为deserialize方法添加更健壮的错误处理逻辑，例如当p.getText()返回的字符串不是有效的JSON时，或者目标类型无法匹配时。
contentAs: 原始问题答案中提到了contentAs，它通常用于处理泛型集合或映射中的元素类型。在我们的RawJsonDeserializer中，createContextual已经动态获取了List<User>的完整JavaType，所以contentAs在此场景下并非必需，Jackson会正确处理List<User>。

Maven依赖: 确保项目中包含了Jackson的核心依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version> <!-- 使用你需要的版本 -->
</dependency>

登录后复制

通过上述方法，我们可以优雅地解决Jackson在反序列化嵌套JSON字符串时的挑战，使得复杂且非标准格式的JSON数据也能被有效地映射到Java对象模型中。

以上就是使用Jackson自定义反序列化器处理嵌套JSON字符串的详细内容，更多请关注php中文网其它相关文章！