欢迎来到雄杰鑫电商资讯网
技术教程

深入理解Jackson处理动态键名JSON的策略

DDD 次阅读

本文探讨了如何使用Jackson库处理JSON数据中包含动态生成键名的情况，并将其序列化与反序列化为Java POJO。文章详细介绍了两种核心策略：通过引入包装类将动态键名封装到Map字段中，以及直接将JSON反序列化为Map类型，并提供了相应的代码示例和注意事项，帮助开发者有效应对此类场景。

在处理外部服务返回的JSON数据时，我们有时会遇到顶级属性键名是动态生成的情况。例如，JSON结构可能如下所示，其中 "random1"、"nextRandom500" 等键是不可预测的：

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

直接将这种结构反序列化到仅包含固定字段的POJO（如 UserResponse 仅有一个 users 字段）会导致 UnrecognizedPropertyException 错误，因为Jackson无法找到与动态键名匹配的POJO属性。为了正确处理这种场景，Jackson提供了两种主要的策略。

1. 策略一：使用包装POJO封装动态键名

如果允许修改JSON的结构，或者可以在客户端对JSON进行预处理，使其包含一个固定的根属性来包裹所有动态键名，那么可以使用一个包含 Map 字段的包装POJO。

1.1 JSON结构调整

将原始JSON调整为如下形式，引入一个固定的根键（例如 "users"）来包含所有动态键名及其对应的值：

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

1.2 POJO定义

首先，定义内部的 User POJO，它代表了每个动态键名对应的值结构：

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

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

然后，定义一个包装POJO UserResponse，其中包含一个 Map 字段，其键名为 "users"，与调整后的JSON结构中的根键对应：

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 users; // 这里的"users"字段将映射到JSON中的"users"键
}

1.3 反序列化与序列化

使用 ObjectMapper 进行反序列化和序列化操作将变得直接：

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

public class JsonProcessingExample {

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

        // 示例JSON (调整后的结构)
        String jsonWithWrapper = "{\n" +
                "  \"users\": {\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" +
                "  }\n" +
                "}";

        // 反序列化
        UserResponse userResponse = objectMapper.readValue(jsonWithWrapper, UserResponse.class);
        System.out.println("Deserialized UserResponse:");
        userResponse.getUsers().forEach((key, user) ->
                System.out.println("  Key: " + key + ", Name: " + user.getName() + ", Last Name: " + user.getLastName()));

        // 序列化回JSON
        String serializedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(userResponse);
        System.out.println("\nSerialized JSON from UserResponse:");
        System.out.println(serializedJson);

        // 构建一个UserResponse对象进行序列化
        UserResponse newUserResponse = new UserResponse();
        Map newUsers = new HashMap<>();
        newUsers.put("newRandomKey1", User.builder().name("Alice").lastName("Smith").build());
        newUsers.put("newRandomKey2", User.builder().name("Bob").lastNam
e("White").build());
        newUserResponse.setUsers(newUsers);

        String newSerializedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(newUserResponse);
        System.out.println("\nSerialized JSON from new UserResponse object:");
        System.out.println(newSerializedJson);
    }
}

2. 策略二：直接反序列化为 Map

如果无法修改JSON的原始结构，或者动态键名本身就是JSON的根，那么可以直接将JSON反序列化为一个 Map 类型。

2.1 POJO定义

在这种策略下，我们只需要定义 User POJO即可，不需要 UserResponse 包装类：

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

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

2.2 反序列化与序列化

由于 Map 是一个泛型类型，Jackson在反序列化时需要 TypeReference 来正确推断类型信息。

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

public class JsonProcessingDirectMapExample {

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

        // 示例JSON (原始结构)
        String originalJson = "{\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" +
                "}";

        // 反序列化为 Map
        Map usersMap = objectMapper.readValue(originalJson,
                new TypeReference>() {});
        System.out.println("Deserialized Map:");
        usersMap.forEach((key, user) ->
                System.out.println("  Key: " + key + ", Name: " + user.getName() + ", Last Name: " + user.getLastName()));

        // 序列化回JSON
        String serializedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(usersMap);
        System.out.println("\nSerialized JSON from Map:");
        System.out.println(serializedJson);

        // 构建一个Map对象进行序列化
        Map newUsersMap = new HashMap<>();
        newUsersMap.put("anotherRandomKeyA", User.builder().name("Charlie").lastName("Brown").build());
        newUsersMap.put("anotherRandomKeyB", User.builder().name("Diana").lastName("Prince").build());

        String newSerializedJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(newUsersMap);
        System.out.println("\nSerialized JSON from new Map object:");
        System.out.println(newSerializedJson);
    }
}

3. 注意事项与总结

  • 选择策略：
    • 如果JSON结构可以调整，且你希望有一个更结构化的Java对象来代表整个响应，那么使用策略一（包装POJO）更为合适。它提供了更好的类型安全性和封装性。
    • 如果JSON结构必须保持原样（动态键名位于根部），并且你只是想获取键值对数据，那么策略二（直接反序列化为 Map）是更直接、更简洁的选择。
  • TypeReference 的使用： 在反序列化泛型类型（如 Map 或 List) 时，Jackson需要 TypeReference 来在运行时获取完整的泛型类型信息，以避免类型擦除带来的问题。
  • POJO的设计： 确保内部的 User POJO与动态键名对应的值结构完全匹配。
  • Lombok依赖： 示例代码使用了Lombok的 @Data, @NoArgsConstructor, @SuperBuilder 注解来简化POJO的编写，实际项目中可根据需要选择使用或手动编写getter/setter/构造函数。
  • Jackson配置： objectMapper.writerWithDefaultPrettyPrinter() 用于生成格式化良好的JSON输出，便于阅读。@JsonInclude(JsonInclude.Include.NON_NULL) 注解在序列化时会忽略值为 null 的字段。

通过理解并应用上述两种策略，开发者可以灵活高效地使用Jackson库处理各种包含动态键名的JSON数据，实现与Java POJO之间的无缝序列化和反序列化。
ai app java js json 键值对 封装性

相关文章

按ESC键退出。