使用Jackson处理JSON中随机键的序列化与反序列化-java教程-PHP中文网

使用Jackson处理JSON中随机键的序列化与反序列化

霞舞

发布： 2025-09-27 11:55:30

原创

380人浏览过

使用Jackson处理JSON中随机键的序列化与反序列化

本文深入探讨了如何使用Jackson库处理JSON数据中包含随机生成顶层键的场景。针对Jackson在默认情况下无法识别动态键的问题，文章提供了两种核心解决方案：一是利用TypeReference直接将JSON反序列化为Map<String, POJO>结构，适用于顶层键完全不可预测的情况；二是调整JSON结构，将其封装在一个固定键下，从而允许使用包含Map字段的POJO进行映射。通过示例代码和注意事项，帮助开发者有效应对此类复杂JSON结构。

1. 理解问题：Jackson与动态JSON键

在处理外部服务返回的json数据时，我们有时会遇到顶层属性键是动态生成、不可预测的情况。例如，以下json结构中，random1、nextrandom500等键是随机的：

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

登录后复制

当尝试使用以下POJO直接反序列化时，Jackson会抛出UnrecognizedPropertyException：

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; 

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

登录后复制

Jackson默认期望POJO中的字段名与JSON中的键名精确匹配。如果JSON的顶层键是动态的，而POJO中没有一个字段能够直接匹配这些动态键，Jackson就无法识别，从而报错。POJO中的private Map<String,User> users;字段期望的是JSON中有一个名为users的顶层键，其值是一个包含用户数据的Map，而不是直接将整个JSON根对象视为一个Map。

2. 解决方案一：直接反序列化为 Map<String, POJO>

最直接且推荐的解决方案是将整个JSON结构视为一个由动态键和User对象组成的Map。Jackson的TypeReference机制非常适合处理泛型类型的反序列化。

2.1 反序列化

我们可以直接将JSON字符串反序列化为一个Map<String, User>对象。

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

public class JsonDeserializationExample {

    // 定义User POJO，与原POJO中的User类相同
    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }

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

        ObjectMapper objectMapper = new ObjectMapper();

        // 使用TypeReference处理泛型Map的反序列化
        Map<String, User> usersMap = objectMapper.readValue(jsonString, 
            new TypeReference<Map<String, User>>(){});

        System.out.println("Deserialized Map: " + usersMap);
        usersMap.forEach((key, user) -> 
            System.out.println("Key: " + key + ", User: " + user.getName() + " " + user.getLastName()));
    }
}

登录后复制

在这个方法中，我们不再需要UserResponse这个顶层POJO，而是直接将JSON映射到Map<String, User>。TypeReference是Jackson用于在运行时保留泛型类型信息的一种机制，它允许Jackson正确地将JSON内容解析为指定泛型类型的集合或Map。

2.2 序列化

如果需要将这个Map<String, User>对象序列化回相同的JSON格式，Jackson也能轻松完成：

// 假设 usersMap 已经填充了数据
Map<String, User> usersMapToSerialize = new java.util.HashMap<>();
usersMapToSerialize.put("dynamicKeyA", new User("Alice", "Smith"));
usersMapToSerialize.put("dynamicKeyB", new User("Bob", "Johnson"));

String serializedJson = objectMapper.writeValueAsString(usersMapToSerialize);
System.out.println("\nSerialized JSON from Map: " + serializedJson);

登录后复制

输出将是：

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

登录后复制

3. 解决方案二：调整JSON结构（添加一个固定键）

如果可能与服务提供方协商，或者在某些场景下，JSON结构实际上可以通过添加一个固定键来封装这些动态键，那么原始的UserResponse POJO设计就变得可行。

序列猴子开放平台

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

查看详情

3.1 预期的JSON结构

如果JSON结构变为如下所示，即所有的动态用户对象都嵌套在一个名为users的固定键下：

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

登录后复制

3.2 使用原始POJO进行反序列化

在这种情况下，原始的UserResponse POJO（包含private Map<String,User> users;字段）就能正确工作：

import com.fasterxml.jackson.databind.ObjectMapper;
// UserResponse 和 User POJO 定义如前所示

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

        ObjectMapper objectMapper = new ObjectMapper();

        UserResponse userResponse = objectMapper.readValue(wrappedJsonString, UserResponse.class);

        System.out.println("Deserialized UserResponse: " + userResponse);
        if (userResponse != null && userResponse.getUsers() != null) {
            userResponse.getUsers().forEach((key, user) ->
                System.out.println("Key: " + key + ", User: " + user.getName() + " " + user.getLastName()));
        }
    }
}

登录后复制

3.3 序列化

将UserResponse对象序列化回这种带固定键的JSON结构同样简单：

// 假设 userResponse 已经填充了数据
UserResponse userResponseToSerialize = new UserResponse();
Map<String, UserResponse.User> usersMap = new java.util.HashMap<>();
usersMap.put("someKey1", new UserResponse.User("Charlie", "Brown"));
usersMap.put("someKey2", new UserResponse.User("Diana", "Prince"));
userResponseToSerialize.setUsers(usersMap);

String serializedWrappedJson = objectMapper.writeValueAsString(userResponseToSerialize);
System.out.println("\nSerialized JSON from UserResponse: " + serializedWrappedJson);

登录后复制

输出将是：

{"users":{"someKey1":{"name":"Charlie","lastName":"Brown"},"someKey2":{"name":"Diana","lastName":"Prince"}}}

登录后复制

4. 注意事项与总结

选择合适的解决方案：
- 如果JSON的顶层键确实是动态且没有固定父键，那么解决方案一（直接反序列化为Map<String, POJO>）是最佳选择。这种方法直接、简洁，且无需修改JSON结构。
- 如果JSON结构可以通过协商调整，或者在某些内部场景下可以控制JSON输出，那么解决方案二（调整JSON结构，添加固定键）可以保持POJO的封装性，使得UserResponse这样的顶层POJO更有意义。
Jackson配置：在某些情况下，你可能希望忽略POJO中不存在的JSON字段，而不是抛出异常。可以通过配置ObjectMapper实现：
```
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
```
登录后复制
但这并不能解决动态键映射到POJO字段的问题，它只是让Jackson在遇到未知字段时跳过而不是报错。对于将动态键映射到Map的需求，上述两种解决方案更为根本。
Lombok与Jackson：示例中使用了Lombok的@Data、@SuperBuilder、@NoArgsConstructor等注解，它们可以简化POJO的编写，自动生成getter/setter、构造函数等，与Jackson配合良好。