当前位置：首页 > 文章列表 > 文章 > java教程 > Jackson处理JSON：动态键序列化技巧

Jackson处理JSON：动态键序列化技巧

2025-10-19 09:24:29 0浏览收藏

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Jackson动态键处理：JSON序列化与反序列化技巧》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

掌握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。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：

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 对象序列化回原始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：动态键序列化技巧》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！