使用Jackson处理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 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 users;字段期望的是JSON中有一个名为users的顶层键，其值是一个包含用户数据的Map，而不是直接将整个JSON根对象视为一个Map。

2. 解决方案一：直接反序列化为 Map

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

2.1 反序列化

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

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 usersMap = objectMapper.readValue(jsonString, 
            new TypeReference>(){});

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

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

2.2 序列化

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

// 假设 usersMap 已经填充了数据
Map 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设计就变得可行。

来福FM

来福 - 你的私人AI电台

下载

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 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 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）是最佳选择。这种方法直接、简洁，且无需修改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配合良好。

通过理解JSON的实际结构和Jackson的反序列化机制，开发者可以灵活选择合适的策略来处理包含动态或随机键的复杂JSON数据，确保数据的正确解析与生成。