掌握Jackson：高效处理JSON中动态键的序列化与反序列化-java教程-PHP中文网

掌握Jackson：高效处理JSON中动态键的序列化与反序列化

碧海醫心

发布： 2025-09-27 10:48:18

原创

286人浏览过

掌握Jackson：高效处理JSON中动态键的序列化与反序列化

本文详细讲解如何使用Jackson库处理JSON数据中包含动态或随机生成键的场景。我们将探讨当JSON根级别存在不确定键时，如何通过TypeReference直接反序列化到Map，以及在特定条件下调整POJO结构以实现更传统的映射。教程涵盖了反序列化和序列化的完整示例，旨在帮助开发者高效、灵活地处理此类复杂的JSON结构。

理解问题：JSON动态键与POJO映射挑战

在与外部服务交互时，我们有时会遇到json数据中的键名并非固定，而是动态生成的情况。例如，以下json结构：

{
    "random1" : {
        "name" : "john",
        "lastName" : "johnson"
    },
    "nextRandom500" : {
        "name" : "jack",
        "lastName" : "jackson"
    },
    "random100500" : {
        "name" : "jack",
        "lastName" : "johnson"
    }   
}

登录后复制

其中 "random1"、"nextRandom500" 等是随机生成的键，它们的值结构相同，都代表一个用户对象。如果尝试使用如下POJO直接反序列化：

import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.Map;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@SuperBuilder(toBuilder=true)
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class UserResponse {
    private Map<String,User> users; // 期望顶层有一个"users"键

    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }
}

登录后复制

Jackson会抛出 UnrecognizedPropertyException 异常，例如 Unrecognized field "random1" (class com.pingidentity.UserResponse), not marked as ignorable。这是因为Jackson在反序列化时，会尝试将JSON根级别的键（如 "random1"）映射到 UserResponse 类中的字段。然而，UserResponse 类中只有一个名为 users 的字段，并没有 "random1" 字段，因此导致映射失败。

为了解决这个问题，我们需要根据JSON的实际结构调整Jackson的反序列化策略。

解决方案一：直接反序列化至Map类型 (推荐)

当JSON的根级别包含动态键，且这些键的值结构统一时，最直接有效的方法是将其反序列化为一个 Map<String, YourObject>。Jackson的 TypeReference 机制为此提供了精确的类型信息，允许我们在运行时指定泛型类型。

1. POJO定义

首先，我们需要定义内部对象 User。为了方便在 TypeReference 中引用，我们将其定义为 UserResponse 的静态内部类。

// UserResponse.java (包含静态内部类User)
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

// UserResponse本身不再作为顶层POJO使用，但其内部的User类是需要的
// 我们可以将User类独立出来，或者像这样作为静态内部类
public class UserResponse { // 顶级类，仅用于包含User
    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }
}

登录后复制

2. 反序列化示例

使用 ObjectMapper 和 TypeReference 将原始JSON反序列化为 Map<String, UserResponse.User>：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import java.util.Map;

public class JsonDynamicKeyProcessor {
    public static void main(String[] args) throws Exception {
        String jsonInput = "{\n" +
                           "    \"random1\" : {\n" +
                           "        \"name\" : \"john\",\n" +
                           "        \"lastName\" : \"johnson\"\n" +
                           "    },\n" +
                           "    \"nextRandom500\" : {\n" +
                           "        \"name\" : \"jack\",\n" +
                           "        \"lastName\" : \"jackson\"\n" +
                           "    },\n" +
                           "    \"random100500\" : {\n" +
                           "        \"name\" : \"jack\",\n" +
                           "        \"lastName\" : \"johnson\"\n" +
                           "    }   \n" +
                           "}";

        ObjectMapper objectMapper = new ObjectMapper();

        // 使用TypeReference指定目标类型为Map<String, UserResponse.User>
        Map<String, UserResponse.User> usersMap = objectMapper.readValue(jsonInput, new TypeReference<Map<String, UserResponse.User>>() {});

        System.out.println("反序列化成功！");
        usersMap.forEach((key, user) ->
            System.out.println("键: " + key + ", 用户名: " + user.getName() + ", 姓氏: " + user.getLastName())
        );
    }
}

登录后复制

3. 序列化示例

将 Map<String, UserResponse.User> 对象序列化回原始JSON格式：

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

查看详情

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

// ... (接上文的UserResponse.User定义)

public class JsonDynamicKeySerializer {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        // 构建一个Map对象，模拟从程序中创建数据
        Map<String, UserResponse.User> usersToSerialize = new HashMap<>();
        usersToSerialize.put("dynamicKeyA", new UserResponse.User("Alice", "Smith"));
        usersToSerialize.put("dynamicKeyB", new UserResponse.User("Bob", "Johnson"));

        // 序列化Map对象
        String serializedJson = objectMapper.writeValueAsString(usersToSerialize);
        System.out.println("\n序列化结果:\n" + serializedJson);
    }
}

登录后复制

输出将是：

{"dynamicKeyA":{"name":"Alice","lastName":"Smith"},"dynamicKeyB":{"name":"Bob","lastName":"Johnson"}}

登录后复制

解决方案二：调整JSON结构以适应POJO (如果可行)

如果能够控制或修改传入的JSON结构，将其中的动态键集合包裹在一个固定的父键下，那么原有的POJO结构就可以直接使用，无需 TypeReference。

1. POJO定义

沿用问题中提供的 UserResponse POJO。这个POJO设计上期望JSON有一个顶层键 "users" 来包含所有动态用户数据。

// UserResponse.java (原始设计)
import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.Map;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@SuperBuilder(toBuilder=true)
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class UserResponse {
    private Map<String,User> users; // 期望顶层有一个"users"键

    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }
}

登录后复制

2. 调整后的JSON示例

为了匹配 UserResponse POJO，JSON结构需要调整为：

{
  "users": {
    "random1" : {
      "name" : "john",
      "lastName" : "johnson"
    },
    "nextRandom500" : {
      "name" : "jack",
      "lastName" : "jackson"
    },
    "random100500" : {
      "name" : "jack",
      "lastName" : "johnson"
    }
  }
}

登录后复制

3. 反序列化示例

使用调整后的JSON结构，可以直接将JSON反序列化为 UserResponse 对象：

import com.fasterxml.jackson.databind.ObjectMapper;

// ... (UserResponse POJO如上所示)

public class JsonWrappedDeserialization {
    public static void main(String[] args) throws Exception {
        String wrappedJsonInput = "{\n" +
                                  "  \"users\": {\n" +
                                  "    \"random1\" : {\n" +
                                  "      \"name\" : \"john\",\n" +
                                  "      \"lastName\" : \"johnson\"\n" +
                                  "    },\n" +
                                  "    \"nextRandom500\" : {\n" +
                                  "      \"name\" : \"jack\",\

登录后复制

以上就是掌握Jackson：高效处理JSON中动态键的序列化与反序列化的详细内容，更多请关注php中文网其它相关文章！